1.概述
进程：正在执行中的程序，一个进程中至少有一个线程。
线程：每个进程执行都有执行顺序，该顺序是一个执行路径，或者叫做控制单元。无论QQ还是迅雷，启动时候会在内存中分配一个地址，进程用于标识空间，封装里面的控制单元。线程是进程里面的控制单元。线程控制进程的运行。
先看一个单线程例子
package com.zhangb;
public class Demo1 {
public static void main(String[] args)
{
System.out.println("hello world");
}
}输出结果：
hello world这个程序即是main函数中的一个线程。更细节说明，这个里面不止这一个线程，还有垃圾回收的线程。
多线程存在的意义
单进程的计算机只能做一件事情,而我们现在的计算机都可以做多件事情。
举例:一边玩游戏(游戏进程),一边听音乐(音乐进程)。
也就是说现在的计算机都是支持多进程的,可以在一个时间段内执行多个任务。
并且呢,可以提高CPU的使用率。
如何自己定义线程
通过对api的查找，java已经提供了对线程这类事物的描述。就Thread类。
创建线程的第一种方式：继承Thread类。
步骤：
1，定义类继承Thread。
2，复写Thread类中的run方法。 目的：将自定义代码存储在run方法。让线程运行。
3，调用线程的start方法，该方法两个作用：启动线程，调用run方法。
package com.zhangb;
public class Demo1 {
public static void main(String[] args) {
ThreadDemo t = new ThreadDemo();//创建好一个线程。
t.start();//开启线程并执行该线程的run方法。
//d.run();//仅仅是对象调用方法。而线程创建了，并没有运行。
// 主线程打印
for (int i = 0; i < 60; i++) {
System.out.println("DemoMain----" + i);
}
}
}
// 1，定义类继承Thread。
class ThreadDemo extends Thread {
// 2.重写run方法
public void run() {
for (int i = 0; i < 60; i++) {
System.out.println("ThreadDemo----" + i);
}
}
}输出结果
DemoMain----0
ThreadDemo----0
ThreadDemo----1
ThreadDemo----2
DemoMain----1
ThreadDemo----3
DemoMain----2
ThreadDemo----4
DemoMain----3
DemoMain----4感兴趣的同学可以自己试试。通过运行发现结果每一次都不同。因为多个线程都获取cpu的执行权。cpu执行到谁，谁就运行。明确一点，在某一个时刻，只能有一个程序在运行。(多核除外)，cpu在做着快速的切换，以达到看上去是同时运行的效果。我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，cpu说的算。
为什么要覆盖run方法呢？
Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。也就是说Thread类中的run方法，用于存储线程要运行的代码。
线程运行状态（生命周期）
给线程重新命名
线程都有自己默认的名称。Thread-编号 该编号从0开始。static Thread currentThread():获取当前线程对象。getName(): 获取线程名称。
设置线程名称：setName或者构造函数。请看实例：
package com.zhangb;
//两个线程交替运行，并且可以重命名线程名称
public class ThreadTest {
public static void main(String[] args)
{
Test t1 = new Test("one---");
Test t2 = new Test("two+++");
t1.start();
t2.start();
// t1.run();
// t2.run();
for(int x=0; x<60; x++)
{
System.out.println("main....."+x);
}
}
}
class Test extends Thread
{
//private String name;
Test(String name)
{
//this.name = name;
// 继承父类，修改线程名称
super(name);
}
public void run()
{
for(int x=0; x<60; x++)
{
System.out.println((Thread.currentThread()==this)+"..."+this.getName()+" run..."+x);
}
}
}创建线程的第二种方式：实现Runable接口
1，定义类实现Runnable接口
2，覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中。
3，通过Thread类建立线程对象。
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。为什么要将Runnable接口的子类对象传递给Thread的构造函数。因为，自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
请看实例：
package com.zhangb;
/**
* 实现Runable 方法开启多线程，卖票小程序
* @author zhangb
*
*/
public class TicketDemo {
public static void main(String[] args) {
Ticket t = new Ticket();
//通过Thread类建立线程对象。
//将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
Thread t1 = new Thread(t);//创建了一个线程；
Thread t2 = new Thread(t);//创建了一个线程；
Thread t3 = new Thread(t);//创建了一个线程；
Thread t4 = new Thread(t);//创建了一个线程；
//调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
t1.start();
t2.start();
t3.start();
t4.start();
/*
Ticket t1 = new Ticket();
//Ticket t2 = new Ticket();
//Ticket t3 = new Ticket();
//Ticket t4 = new Ticket();
t1.start();
t1.start();
t1.start();
t1.start();
*/
}
}
//1定义类实现Runnable接口
class Ticket implements Runnable //extends Thread
{
private int ticket = 100;
// 2覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中(卖票)
@Override
public void run() {
while (true) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName()+"卖票 ing...."+ticket--);
}
}
}
}线程安全问题
package com.zhangb;
/**
* 实现Runable 方法开启多线程，卖票小程序
* @author zhangb
*/
public class TicketDemo2 {
public static void main(String[] args) {
Ticket1 t = new Ticket1();
//通过Thread类建立线程对象。
//将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
Thread t1 = new Thread(t);//创建了一个线程；
Thread t2 = new Thread(t);//创建了一个线程；
Thread t3 = new Thread(t);//创建了一个线程；
Thread t4 = new Thread(t);//创建了一个线程；
//调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
t1.start();
t2.start();
t3.start();
t4.start();
}
}
//1定义类实现Runnable接口
class Ticket1 implements Runnable //extends Thread
{
private int ticket = 100;
// 2覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中(卖票)
@Override
public void run() {
while (true) {
if (ticket > 0) {
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"卖票 ing...."+ticket--);
}
}
}
}查看结果：
通过分析，发现，打印出0，-1，-2等错票。
多线程的运行出现了安全问题。
问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，
另一个线程参与进来执行。导致共享数据的错误。
解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式。就是同步代码块。
synchronized(对象)
{
需要被同步的代码
}
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
同步的前提：
1，必须要有两个或者两个以上的线程。
2，必须是多个线程使用同一个锁。
必须保证同步中只能有一个线程在运行。
好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源，
将上面的代码改为如下即可解决安全问题：
synchronized(obj)
{
if(tick>0)
{
//try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
}
}单例设计模式中如何避免安全问题
单例设计模式如果要让其更加的严谨，我们也是需要使用同步锁进行处理，让程序更加的严谨可靠
package com.zhangb;
public class SingleDemo {
}
//饿汉式 此处给出样例
/*class Single
{
private static final Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}*/
//懒汉式的安全问题，懒汉式的特点，延迟加载
class Single{
private static Single s = null;
private Single(){}
public static Single getInstance(){
//此处多个对象调用的时候 Single() 可能会被用多次
if (s == null){
s= new Single();
}
return s;
}
//方法一 给类加同步锁 缺点是每次都会重新创建对象，效率较低
public static synchronized Single getInstance1(){
//此处多个对象调用的时候 Single() 可能会被用多次
if (s == null){
s= new Single();
}
return s;
}
//方法二：同步调用的块方法,双重判断的方法
public static Single getInstance2(){
//此处多个对象调用的时候 Single() 可能会被用多次
if (s == null){
synchronized (Single.class) {
if (s == null) {
s= new Single();
}
}
}
return s;
}
}死锁
经典的“哲学家进餐”问题很好的描述了死锁的情况。5个哲学家吃中餐，坐在一张圆桌上，有5根筷子，每个人吃饭必须用两根筷子。哲学家时而思考时而进餐。分配策略有可能导致哲学家永远无法进餐。
类似的，当线程A尝试持有锁L1，并尝试获取锁L2；同时，线程B持有锁L2，并尝试获取锁L1，并且都不释放已经拥有的锁。这就是最简单的死锁。其中存在环状的锁依赖关系。称为“抱死”。
数据库系统有监视、检测死锁的环节。当两个事务需要的锁相互依赖时，DB将选择一个牺牲者放弃这个事务，牺牲者会释放持有的资源，从而使其他事务顺利的执行。
JVM在解决死锁问题时并没有数据库系统那么强大，当一组线程发生死锁时，那么这写线程就凉凉——永远不会被使用。请看实例代码
package com.zhangb;
//1.实现Runable方式开启多线程
class Test1 implements Runnable {
private boolean flag;
Test1(boolean flag) {
this.flag = flag;
}
//重写run方法
public void run() {
if (flag) {
while (true) {
// if locka ,if locka只会执行一个，相互抢资源
synchronized (MyLock.locka) {
System.out.println(Thread.currentThread().getName() + "...if locka ");
synchronized (MyLock.lockb) {
System.out.println(Thread.currentThread().getName() + "..if lockb");
}
}
}
} else {
while (true) {
// else lockaelse lockb只会执行一个，相互抢资源
synchronized (MyLock.lockb) {
System.out.println(Thread.currentThread().getName() + "..else lockb");
synchronized (MyLock.locka) {
System.out.println(Thread.currentThread().getName() + ".....else locka");
}
}
}
}
}
}
class MyLock {
static Object locka = new Object();
static Object lockb = new Object();
}
public class DeadLockTest {
public static void main(String[] args) {
Thread t1 = new Thread(new Test1(true));
Thread t2 = new Thread(new Test1(false));
t1.start();
t2.start();
}
}执行结果
多线程间通讯
还在学习，持续更新中。。
