Java并发

目录

• 1 引
  
  • 1.1 线程与进程
  • 1.2 线程的状态
  • 1.3 线程实现的方法
  • 1.4 线程常用的方法
  • 1.5 基础线程机制
  • 1.6 停止线程的方法
• 2 多线程基础
  
  • 2.1同步
    
    • synchronized机制
    • 同步锁（Lock）机制
    • volatile关键字实现同步
    • 使用阻塞队列LinkedBlockingQueue
    • 使用AtometicInteger
    • 小结
  • 2.2 死锁
    
    • 死锁的原因
    • 解决死锁的方法
• 3 多线程通信
  
  • join()机制
  • wait/notify机制
  • await() signal()机制

1. 引

1.1 线程与进程

• 进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位
• 线程：进程中负责程序执行的执行单元。线程本身依靠程序进行运行。线程是程序中的顺序控制流，只能使用分配给程序的资源和环境。
• 进程：执行中的程序，一个进程至少包含一个线程。
• 单线程：程序中只存在一个线程，实际上主方法就是一个主线程。
• 多线程：在一个程序中运行多个任务，目的是更好地使用CPU资源。

1.2 线程的状态

  如上图所示，线程包含七种状态：

• 创建（new）状态: 准备好了一个多线程的对象
• 就绪（runnable）状态: 调用了start()方法, 等待CPU进行调度
• 运行（running）状态: 执行run()方法
• 阻塞（blocked）状态: 暂时停止执行, 可能将资源交给其它线程使用
• 期限等待（time waiting）状态：不会被分配CPU执行权，但是无需等待其他进程显式唤醒，在一定时间后它们会由系统自动唤醒。
• 无期限等待（waiting）状态：不会分配CPU执行权，需要其他进程显式唤醒。
• 终止（terminated）状态: 线程销毁

  创建（new）状态：当需要新起一个线程来执行某个子任务时，就创建了一个线程。但是线程创建之后，不会立即进入就绪状态，因为线程的运行需要一些条件，只有线程运行需要的所有条件满足了，才进入就绪状态。
  就绪（runnable）状态：当线程进入就绪状态后，不代表立刻就能获取CPU执行时间，也许此时CPU正在执行其他的事情，因此它要等待。当得到CPU执行时间之后，线程便真正进入运行状态。
  运行（running）状态：线程在运行状态过程中，可能有多个原因导致当前线程不继续运行下去，比如用户主动让线程睡眠（睡眠一定的时间之后再重新执行）、用户主动让线程等待，或者被同步块给阻塞，此时就对应着多个状态：time waiting（睡眠或等待一定的事件）、waiting（等待被唤醒）、blocked（阻塞）。
  阻塞（blocked）状态：BLOCKED称为阻塞状态，或者说线程已经被挂起，它“睡着”了，原因通常是它在等待一个“锁”，当尝试进入一个synchronized语句块/方法时，锁已经被其它线程占有，就会被阻塞，直到另一个线程走完临界区或发生了相应锁对象的wait()操作后，它才有机会去争夺进入临界区的权利
  在Java代码中，需要考虑synchronized的粒度问题，否则一个线程长时间占用锁，其它争抢锁的线程会一直阻塞，直到拥有锁的线程释放锁
  处于BLOCKED状态的线程，即使对其调用 thread.interrupt()也无法改变其阻塞状态，因为interrupt()方法只是设置线程的中断状态，即做一个标记，不能唤醒处于阻塞状态的线程。（但是能将处于wait状态的线程强制唤醒）。
  注意：ReentrantLock.lock()操作后进入的是WAITING状态，其内部调用的是LockSupport.park()方法
  无期限等待（waiting）状态：处于无期限等待状态的线程不会被分配CPU执行时间，它们要等待显示的被其它线程唤醒。这种状态通常是指一个线程拥有对象锁后进入到相应的代码区域后，调用相应的“锁对象”的wait()方法操作后产生的一种结果。变相的实现还有LockSupport.park()、Thread.join()等，它们也是在等待另一个事件的发生，也就是描述了等待的意思。

  注意：
  LockSupport.park(Object blocker) 会挂起当前线程，参数blocker是用于设置当前线程的“volatile Object parkBlocker 成员变量”
  parkBlocker 是用于记录线程是被谁阻塞的，可以通过LockSupport.getBlocker()获取到阻塞的对象，用于监控和分析线程用的。
  “阻塞”与“等待”的区别：

• “阻塞”状态是等待着获取到一个排他锁，进入“阻塞”状态都是被动的，离开“阻塞”状态是因为其它线程释放了锁，不阻塞了；
• “等待”状态是在等待一段时间 或者 唤醒动作的发生，进入“等待”状态是主动的。

  期限等待（time waiting）状态：处于期限等待状态的线程也不会被分配CPU执行时间，不过无需等待被其它线程显示的唤醒，在一定时间之后它们会由系统自动的唤醒。

  消亡（terminated）状态:当由于突然中断或者子任务执行完毕，线程就会被消亡。

1.3 实现线程的方法

  实现线程有三种方法：

• 继承 Thread 类。
• 实现 Runnable 接口；
• 实现 Callable 接口;

1.3.1 继承Tread类

(1)步骤：

• 定义一个类(记为classA)继承Thread类。
• 覆盖Thread类中的run方法。
• 直接用classA创建对象。
• 使用对象调用start()方法。

/**
 * 通过继承Thread的方法创建线程
 */
class MyThread extends Thread
{
    @Override
    public void run() {
        System.out.println("创建的线程："+ Thread.currentThread().getName());
    }
}
public class ExtendThreadClass {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

(2)注意：
  在main中调用run（）方法和调用其他普通的方法一样，此时只有主线程一个线程，此时cpu被主线程占据，是在主线程中执行，currentThread（）返回的是主线程main，线程名和线程id是主线程的；而调用start（）方法是开始执行一个新线程，此时cpu被该线程占据，是在该线程中执行，currentThread（）返回的是该线程，线程名和线程id就是该线程自己的了。如下：

class MyThread extends Thread
{
    @Override
    public void run() {
        System.out.println("创建的线程："+ Thread.currentThread().getName()+" "+Thread.currentThread().getId());
    }
}
public class ExtendThreadClass {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();  //创建的线程：Thread-0 11
        myThread.run();    //创建的线程：main 1
    }
}

1.3.2实现Runnable接口

(1)步骤：

• 定义类实现Runnable接口。
• 覆盖街扩中的run方法，将线程的任务代码封装到run方法中。
• 通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的 参数进行传递。为什么？因为线程任务都封装在Runnable接口子类对象的run方法中。
• 调用线程对象的star方法开启线程。

/**
 * 实现Runnable接口创建线程
 */
class MyThread implements Runnable
{
    @Override
    public void run() {
        System.out.println("创建的线程: "+Thread.currentThread().getName()+" "+Thread.currentThread().getId());
    }
}
public class ImplRunnableInter {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread t0 = new Thread(myThread);
        t0.start();
    }
}

1.3.3 实现Callable接口：使用ExecutorService、Callable、Future实现有返回结果的多线程

  可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须实现Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现有返回结果的多线程了。

/**
 *实现callable接口创建线程
 */
class MyCallable implements Callable<Object>
{
    private String taskNum;
    MyCallable(String taskNum)
    {
        this.taskNum = taskNum;
    }
    @Override
    public Object call() {
        System.out.println(">>>"+taskNum+"任务启动");
        Date dateTmp1 = new Date();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Date dateTmp2 = new Date();
        long time = dateTmp2.getTime() - dateTmp1.getTime();
        System.out.println(">>>"+taskNum + "任务终止");
        return taskNum + "任务返回运行结果，当前任务时间["+time+"毫秒]";
    }
}
public class ImplCallableInter {
    public static void main(String[] args) {
        System.out.println("程序开始运行..........");
        Date date1 = new Date();
        int taskSize = 5;   //线程池中可以容纳的线程数量
        ExecutorService pool = Executors.newFixedThreadPool(taskSize);  //创建一个线程池
        List<Future> list = new ArrayList<Future>(); //创建有多个返回值的任务
        for(int i = 0; i < taskSize; i++)
        {
            Callable c = new MyCallable(i + " ");
            Future f = pool.submit(c);  //执行任务并获取Future对象
            list.add(f);
        }
        pool.shutdown(); //关闭线程池
        /**
         * 获取所有并发任务的运行结果
         */
        for(Future f : list)
        {
            try {
                System.out.println(">>>"+f.get().toString()); //从future对象上获取任务的返回值，并输出到控制台
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        Date date2 = new Date();
        System.out.println("程序运行结束.......，程序运行时间["+(date2.getTime() - date1.getTime())+"毫秒]");
    }
}

  代码说明：
  上述代码中Executors类，提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。
  ExecutoreService提供了submit()方法，传递一个Callable，或Runnable，返回Future。如果Executor后台线程池还没有完成Callable的计算，调用返回Future对象的get()方法，会阻塞直到计算完成

1.3.4 实现接口VS继承Thread类

实现接口会更好一些，因为：

• Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
• 类可能只要求可执行就行，继承整个 Thread 类开销过大。

1.4 线程常用的方法

  线程常用的方法有如下几个：

1.4.1 静态方法

currentThread()方法

  currentThread()方法可以返回代码段正在被哪个线程调用的信息。

sleep()方法

  sleep()的作用是在指定的毫秒数内让当前“正在执行的线程”休眠（暂停执行）。这个“正在执行的线程”是指this.currentThread()返回的线程。注意：sleep方法不释放锁，但是释放CPU执行权。

yield()方法

  调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。

  注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。

  使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。

1.4.2 静态方法

start()方法

  start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。

run()方法

  run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。

getId()

  getId()的作用是取得线程的唯一标识。

isAlive()方法

  方法isAlive()的功能是判断当前线程是否处于活动状态。方法isAlive()的作用是测试线程是否处于活动状态。什么是活动状态呢？活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备开始运行的状态，就认为线程是“存活”的。

/**
 * 测试isAlive函数
 */
class MyThread extends Thread
{
    @Override
    public void run() {
        System.out.println("run= "+this.isAlive());
    }
}
public class IsAliveTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        System.out.println("begin: "+myThread.isAlive());
        myThread.start();
        System.out.println("end: "+myThread.isAlive());
    }
}

  上述程序执行结果不确定，某次的执行结果为:

begin: false
end: true
run= true

  虽然上面的实例中end打印的值是true,但此值是不确定的。打印true值是因为myThread线程还未执行完毕，所以输出true。如果代码改成下面这样，加了个sleep休眠：

public class IsAliveTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        System.out.println("begin: "+myThread.isAlive());
        myThread.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end: "+myThread.isAlive());
    }
}

  打印结果为：

begin: false
run= true
end: false

join()函数

  在很多情况下，主线程创建并启动了线程，如果子线程中要进行大量耗时运算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join()方法了。方法join()的作用是等待线程对象销毁。
  更一般地说，在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行；join方法中如果传入参数，则表示：如果A线程中调用B线程的join(10)，则表示A线程会等待B线程执行10毫秒，10毫秒过后，A、B线程并行执行。所以也可以说join()方法能够使得线程之间的并行执行变为串行执行。
  那么join()方法的原理是什么呢？
  其实，join方法是通过调用线程的wait方法来达到同步的目的的。例如，A线程中调用了B线程的join方法，则相当于A线程调用了B线程的wait方法，在调用了B线程的wait方法后，A线程就会进入阻塞状态，具体看下面的源码：

public final synchronized void join(long millis)
throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }
    if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

问题：为什么wait()后等待的是主线程而不是调用join()函数的线程对象？？为什么自己写的程序用线程对象调用wait()函数时，等待的就是该线程对象？？？

这个应该是谁调用join()函数谁阻塞，而和调用的谁的join()函数无关。

getName和setName

  用来得到或者设置线程名称。

getPriority和setPriority

  用来获取和设置线程优先级。

setDaemon和isDaemo

  用来设置线程是否成为守护线程和判断线程是否是守护线程。
  守护线程和用户线程的区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖(守护线程就像一个仆人，为主人(创建它的线程)服务，主人没了它也就没了)。举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像垃圾收集器线程就是守护线程。

1.5 基础线程机制

Executor

  Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。
  主要有三种 Executor

• CachedThreadPool：一个任务创建一个线程；
• FixedThreadPool：所有任务只能使用固定大小的线程；
• SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。

public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    for (int i = 0; i < 5; i++) {
        executorService.execute(new MyRunnable());
    }
    executorService.shutdown();
}

Daemon

  在Java线程中有两种线程，一种是User Thread（用户线程），另一种是Daemon Thread(守护线程)。
  Daemon的作用是为其他线程的运行提供服务，比如说GC线程。其实User Thread线程和Daemon Thread守护线程本质上来说去没啥区别的，唯一的区别之处就在虚拟机的离开：如果User Thread全部撤离，那么Daemon Thread也就没啥线程好服务的了，所以虚拟机也就退出了。
  守护线程并非虚拟机内部可以提供，用户也可以自行的设定守护线程，方法：public final void setDaemon(boolean on) ；但是有几点需要注意：

• thread.setDaemon(true)必须在thread.start()之前设置，否则会抛出一个IllegalThreadStateException异常。不能把正在运行的常规线程设置为守护线程。 （备注：这点与守护进程有着明显的区别，守护进程是创建后，让进程摆脱原会话的控制+让进程摆脱原进程组的控制+让进程摆脱原控制终端的控制；所以说寄托于虚拟机的语言机制跟系统级语言有着本质上面的区别）
• 在Daemon线程中产生的新线程也是Daemon的。 （这一点又是有着本质的区别了：守护进程fork()出来的子进程不再是守护进程，尽管它把父进程的进程相关信息复制过去了，但是子进程的进程的父进程不是init进程，所谓的守护进程本质上说就是“父进程挂掉，init收养，然后文件0,1,2都是/dev/null，当前目录到/”）
• 不是所有的应用都可以分配给Daemon线程来进行服务，比如读写操作或者计算逻辑。因为在Daemon Thread还没来的及进行操作时，虚拟机可能已经退出了。

sleep()

  Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
  sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。

yield()

  对静态方法 Thread.yield()的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。

1.6 停止线程的方法

使用stop方法强行终止线程

  不推荐使用这个方法，因为stop和suspend及resume一样，都是作废过期的方法，使用他们可能产生不可预料的结果。

使用退出标志，使线程正常退出，也就是当run方法完成后线程终止

  要想使线程在某一特定条件下退出，最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出：

/**
 * 使用标志位来退出线程
 */
class MyThread extends Thread
{
    public volatile boolean exitFlag = false;
    @Override
    public void run() {
        while(! exitFlag)
        {
            System.out.println("我还没退出 "+Thread.currentThread().getName()+" "+Thread.currentThread().getId());
        }
    }
}
public class ExitThread {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        try {
            Thread.sleep(1000);    //主线程睡1s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myThread.exitFlag = true;
        try {
            myThread.join();         //等待线程退出
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我已退出");
    }
}

  在定义exit时，使用了一个Java关键字volatile，这个关键字的目的是使exitFlag同步，也就是说在同一时刻只能由一个线程来修改exitFlag的值。
  但是有一种情况下使用标志也是退不出线程的，比如下面：

/**
 * 使用标志位来退出线程
 */
class MyThread extends Thread
{
    public volatile boolean exitFlag = false;
    @Override
    public synchronized void run() {
        while(! exitFlag)
        {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我还没退出 "+Thread.currentThread().getName()+" "+Thread.currentThread().getId());
        }
    }
}
public class ExitThread {
    public static void main(String[] args) {
        MyThread myThread0 = new MyThread();
        MyThread myThread1 = new MyThread();
        myThread0.start();
        myThread1.start();
        try {
            Thread.sleep(1000);    //主线程睡1s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myThread0.exitFlag = true;
        myThread1.exitFlag = true;
        System.out.println("我已退出");
    }
}

  该程序中，在run方法上加了同步锁，并且加了wait函数，这种情况下，两个子线程都停不下来，但是主线程可以停。

使用interrupt方法中断线程，但这个不会终止一个正在运行的线程，还需要加入一个判断才可以完成线程的停止

  使用interrupt()方法来中断线程有两种情况：
  (1)线程处于阻塞状态：如使用了sleep,同步锁的wait,socket中的receiver,accept等方法时，会使线程处于阻塞状态。当调用线程的interrupt()方法时，会抛出InterruptException异常。阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后break跳出循环状态或者修改标志位，从而让我们有机会结束这个线程的执行。也就是说，interrupt()方法其实是将线程强制唤醒，让它们具有执行资格，然后再将其停止。但强制动作发生时会产生InterruptedException，所以要处理一下。通常很多人认为只要调用interrupt方法线程就会结束，实际上是错的， 一定要先捕获InterruptedException异常之后通过break来跳出循环，才能正常结束run方法。例子如下：

/**
 * interrupt方法结束线程
 */
class MyThread extends Thread
{
    @Override
    public void run() {
        while (true)
        {
            try {
                sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                break;
            }
            System.out.println("子线程还没退出");
        }
    }
}
public class InterruptExitThread {
    public static void main(String[] args) {
        MyThread myThread0 = new MyThread();
        myThread0.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myThread0.interrupt();
        System.out.println("主线程退出");
    }
}

  本例中，在主线程中调用myThread0线程的interrupt()并且在run方法中用break跳出循环，最终结果是打印InterruptedException信息，并且程序能够终止。
  （2）线程未处于阻塞状态：使用isInterrupted()判断线程的中断标志来退出循环。当使用interrupt()方法时，中断标志就会置true，和使用自定义的标志来控制循环是一样的道理。如下例：

public class ThreadSafe extends Thread {
    public void run() {
        while (!isInterrupted()){
            //do something, but no throw InterruptedException
        }
    }
}

  为什么要区分进入阻塞状态和和非阻塞状态两种情况了，是因为当阻塞状态时，如果有interrupt()发生，系统除了会抛出InterruptedException异常外，还会调用interrupted()函数，调用时能获取到中断状态是true的状态，调用完之后会复位中断状态为false，所以异常抛出之后通过isInterrupted()是获取不到中断状态是true的状态，从而不能退出循环。
  因此在线程未进入阻塞的代码段时是可以通过isInterrupted()来判断中断是否发生来控制循环，在进入阻塞状态后要通过捕获异常来退出循环。因此使用interrupt()来退出线程的最好的方式应该是两种情况都要考虑：

public class ThreadSafe extends Thread {
    public void run() {
        while (!isInterrupted()){ //非阻塞过程中通过判断中断标志来退出
            try{
                Thread.sleep(5*1000);//阻塞过程捕获中断异常来退出
            }catch(InterruptedException e){
                e.printStackTrace();
                break;//捕获到异常之后，执行break跳出循环。
            }
        }
    }
}

2. 多线程基础

2.1 同步

  同步的方法大概有以下几种：

synchronized机制

(1) 同步代码块

  它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。同步代码块的格式如下：

synchronized(对象)
{
    需要被同步的代码;
}

/**
 * 卖票案例：同步代码块
 */
class Ticket implements Runnable
{
    private int num = 100;
    @Override
    public void run() {
        while (true)
        {
            synchronized (this)
            {
                if(num > 0)
                {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"...sale...."+num--);
                }
                else
                {
                    break;
                }
            }
        }
    }
}
public class TicketDemo {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        Thread t0 = new Thread(ticket);
        Thread t1 = new Thread(ticket);
        t0.start();
        t1.start();
    }
}

(2)同步函数

  同步函数就是将同步关键字synchronized加载需要被同步的函数上，函数内部是需要被同步的代码，示例如下：

/**
 * 多线程同步：存钱问题
 */
class Bank{
    private int sum;
    public synchronized void add(int num){
        sum += num;
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sum= :"+sum);
    }
}
class Customer implements Runnable{
    private Bank bank = new Bank();
    @Override
    public void run() {
        for(int i = 0; i < 3; i++){
            bank.add(100);
        }
    }
}
public class BandDemo {
    public static void main(String[] args) {
        Customer customer = new Customer();
        Thread t1 = new Thread(customer);
        Thread t2 = new Thread(customer);
        t1.start();
        t2.start();
    }
}

(3)同步一个类

  作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。

public class SynchronizedExample {
    public void func2() {
        synchronized (SynchronizedExample.class) {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }
}
public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    SynchronizedExample e2 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func2());
    executorService.execute(() -> e2.func2());
}
结果为：0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

同步锁机制（Lock）

  使用显式的lock来进行同步，一个lock上面可以挂多个监视器。示例如下：

/**
 * 多生产者和消费者问题:lock
 */
class Resource
{
    private String name;
    private int count;
    private boolean flag = false;
    Lock lock = new ReentrantLock();
    Condition producerLock = lock.newCondition();
    Condition customerLock = lock.newCondition();
    public void set(String name)
    {
        lock.lock();
        try {
            while (flag)//flag为1，表示还没消费完
            {
                try {
                    producerLock.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            this.name = name + count;
            count++;
            System.out.println(Thread.currentThread().getName() + " 生产者...... " + this.name);
            flag = true;
            customerLock.signal();
        }
        finally {
            lock.unlock();
        }
    }
    public void out()
    {
        lock.lock();
        try {
            while(! flag)
            {
                try {
                    customerLock.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //this.name = name + count;
            //count--;
            System.out.println(Thread.currentThread().getName()+" 消费者............... " +this.name);
            flag = false;
            producerLock.signal();
        }
        finally {
            lock.unlock();
        }
    }
}
class Producer implements Runnable
{
    private Resource resource;
    public Producer(Resource resource)
    {
        this.resource = resource;
    }
    @Override
    public void run() {
        while(true)
        {
            resource.set("烤鸭");
        }
    }
}
class Customer implements Runnable
{
    private Resource resource;
    public Customer(Resource resource)
    {
        this.resource = resource;
    }
    @Override
    public void run() {
        while(true)
        {
            resource.out();
        }
    }
}
public class ProducerAndCustomer {
    public static void main(String[] args) {
        Resource resource = new Resource();
        Producer producer = new Producer(resource);
        Customer customer = new Customer(resource);
        Thread t0 = new Thread(producer);
        Thread t1 = new Thread(producer);
        Thread t2 = new Thread(customer);
        Thread t3 = new Thread(customer);
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

volatile关键字实现同步

  volatile关键字为域变量的访问提供了一种免锁机制，使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新，因此每次使用该域就要重新计算，而不是使用寄存器中的值，volatile不会提供任何原子操作，它也不能用来修饰final类型的变量。
  注：多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。用final域，有锁保护的域和volatile域可以避免非同步的问题。
示例如下：

/**
 * 卖票案例：volatile关键字
 */
class Ticket implements Runnable
{
    private volatile int num = 100;
    @Override
    public void run() {
        while (true)
        {
            if(num > 0)
            {
                System.out.println(Thread.currentThread().getName()+"...sale...."+num--);
            }
            else
            {
                break;
            }
        }
    }
}
public class VolatileDemo {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        Thread t0 = new Thread(ticket);
        Thread t1 = new Thread(ticket);
        t0.start();
        t1.start();
    }
}

使用阻塞队列LinkedBlockingQueue实现线程同步

  阻塞队列的特点是，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。
  LinkedBlockingQueue是一个基于已连接节点的，范围任意的blocking queue。
  LinkedBlockingQueue 类常用方法：

  BlockingQueue定义了阻塞队列的常用方法，尤其是三种添加元素的方法，我们要多加注意，当队列满时：add()方法会抛出异常；offer()方法返回false；put()方法会阻塞。

/**
 * 用阻塞队列实现线程同步 LinkedBlockingQueue的使用
 */
public class BlockingSynchronizedThread {
    /**
     * 定义一个阻塞队列用来存储生产出来的商品
     */
    private LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
    /**
     * 定义生产商品个数
     */
    private static final int size = 10;
    /**
     * 定义启动线程的标志，为0时，启动生产商品的线程；为1时，启动消费商品的线程
     */
    private int flag = 0;
    private class LinkBlockThread implements Runnable {
        @Override
        public void run() {
            int new_flag = flag++;
            System.out.println("启动线程 " + new_flag);
            if (new_flag == 0) {
                for (int i = 0; i < size; i++) {
                    System.out.println("生产商品：" + i + "号");
                    try {
                        queue.put(i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("仓库中还有商品：" + queue.size() + "个");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } else {
                for (int i = 0; i < size / 2; i++) {
                    try {
                        int n = queue.take();
                        System.out.println("消费者买去了" + n + "号商品");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("仓库中还有商品：" + queue.size() + "个");
                    try {
                        Thread.sleep(100);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public static void main(String[] args) {
        BlockingSynchronizedThread bst = new BlockingSynchronizedThread();
        LinkBlockThread lbt = bst.new LinkBlockThread();
        Thread thread1 = new Thread(lbt);
        Thread thread2 = new Thread(lbt);
        thread1.start();
        thread2.start();
    }
}

使用AtometicInteger定义原子变量实现同步

  需要使用线程同步的根本原因在于对普通变量的操作不是原子的。那么什么是原子操作呢？原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作。即-这几种行为要么同时完成，要么都不完成。
  在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，使用该类可以简化线程同步。其中AtomicInteger可以用原子方式更新int的值，可用在应用程序中(如以原子方式增加的计数器)，但不能用于替换Integer；可扩展Number，允许那些处理机遇数字类的工具和实用工具进行统一访问。
  AtomicInteger类常用方法：

/**
 * 卖票案例：AtomicInteger
 */
class Ticket implements Runnable
{
    private AtomicInteger num = new AtomicInteger(100);
    @Override
    public void run() {
        while (true)
        {
            if(num.get() > 0)
            {
                System.out.println(Thread.currentThread().getName()+"...sale...."+num.getAndDecrement());//注意这里
            }
            else
            {
                break;
            }
        }
    }
}
public class AutometicIntegerDemo {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        Thread t0 = new Thread(ticket);
        Thread t1 = new Thread(ticket);
        t0.start();
        t1.start();
    }
}

小结

同步函数和同步代码块的锁

• 所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
• 所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！
• 对于同步块，由于其锁是可以选择的，所以只有使用同一把锁的同步块之间才有着竞争条件。
  也就是说：
  

  • 同步代码块使用的锁是任意的对象，只要保证多个线程使用的是唯一的锁就行。
    
  • 非静态同步函数使用的锁是this。
    
  • 静态同步函数使用的锁是 类名.class或者this.getClass（比较别扭）。

ReentrantLock和synchronized比较

• 锁的实现
  synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
• 性能
  新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
• 等待可中断
  当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
  ReentrantLock 可中断，而 synchronized 不行。
• 公平锁
  公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
  synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
• 锁绑定多个条件
  一个 ReentrantLock 可以同时绑定多个 Condition 对象。

  使用选择：除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。

2.2 死锁

死锁的示例：同步的嵌套

  Java中死锁最简单的情况是，一个线程T1持有锁L1并且申请获得锁L2，而另一个线程T2持有锁L2并且申请获得锁L1，因为默认的锁申请操作都是阻塞的，所以线程T1和T2永远被阻塞了。导致了死锁。这是最容易理解也是最简单的死锁的形式。但是实际环境中的死锁往往比这个复杂的多。可能会有多个线程形成了一个死锁的环路，比如：线程T1持有锁L1并且申请获得锁L2，而线程T2持有锁L2并且申请获得锁L3，而线程T3持有锁L3并且申请获得锁L1，这样导致了一个锁依赖的环路：T1依赖T2的锁L2，T2依赖T3的锁L3，而T3依赖T1的锁L1。从而导致了死锁。
  所以，总结起来死锁产生的原因有两个:

• 锁的嵌套;
• 申请锁是默认阻塞的;

  示例1如下：

/**
 * 死锁：同步的嵌套
 */
class Test implements Runnable
{
    private boolean flag;
    Test(boolean flag)
    {
        this.flag = flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        if(flag)
        {
            while(true)
            {
                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)
            {
                synchronized (MyLock.lockb)
                {
                    System.out.println(Thread.currentThread().getName()+" else lockb...");
                    synchronized (MyLock.locka)
                    {
                        System.out.println(Thread.currentThread().getName()+" else locka...");
                    }
                }
            }
        }
    }
}
class MyLock{
    public static final Object locka = new Object();
    public static final Object lockb = new Object();
}
public class DeadLock {
    public static void main(String[] args) {
//        Test a = new Test(true);
//        Test b = new Test(false);
//
//        Thread t1 = new Thread(a);
//        Thread t2 = new Thread(b);
//
//        t1.start();
//        t2.start();
        Test a = new Test(true);
        Thread t1 = new Thread(a);
        Thread t2 = new Thread(a);
        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        a.setFlag(false);
        t2.start();
    }
}

  示例2如下：

/**
 * 死锁：同步的嵌套
 */
class Test implements Runnable
{
    private boolean flag;
    Lock locka = new ReentrantLock();
    Lock lockb = new ReentrantLock();
    Test(boolean flag)
    {
        this.flag = flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        if(flag)
        {
            while(true)
            {
                try {
                    locka.lock();
                    System.out.println(Thread.currentThread().getName()+" if locka.....");
                    try {
                        lockb.lock();
                        System.out.println(Thread.currentThread().getName()+" if lockb......");
                    }
                    finally {
                        lockb.unlock();
                    }
                }
                finally {
                    locka.unlock();
                }
            }
        }
        else
        {
            while(true)
            {
                try {
                    lockb.lock();
                    System.out.println(Thread.currentThread().getName()+" if locka.....");
                    try {
                        locka.lock();
                        System.out.println(Thread.currentThread().getName()+" if lockb......");
                    }
                    finally {
                        locka.unlock();
                    }
                }
                finally {
                    lockb.unlock();
                }
            }
        }
    }
}
class MyLock{
    public static final Object locka = new Object();
    public static final Object lockb = new Object();
}
public class DeadLock {
    public static void main(String[] args) {
        Test a = new Test(true);
        Thread t1 = new Thread(a);
        Thread t2 = new Thread(a);
        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        a.setFlag(false);
        t2.start();
    }
}

死锁的解决办法

（1）如上死锁产生的原因所示，如果能够避免在一个同步方法中调用其他的同步方法，就能避免死锁。

（2）如果无法避免同步的嵌套，只要让方法申请锁的顺序一致，就能够避免死锁。示例如下（该程序和上面的死锁示例基本形同，只是变化了一下申请锁的顺序，两个方法都是先申请locka在申请lockb）：

class Test implements Runnable
{
    private boolean flag;
    Test(boolean flag)
    {
        this.flag = flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        if(flag)
        {
            while(true)
            {
                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)
            {
                synchronized (MyLock.locka)
                {
                    System.out.println(Thread.currentThread().getName()+" else lockb...");
                    synchronized (MyLock.lockb)
                    {
                        System.out.println(Thread.currentThread().getName()+" else locka...");
                    }
                }
            }
        }
    }
}
class MyLock{
    public static final Object locka = new Object();
    public static final Object lockb = new Object();
}
public class DeadLock {
    public static void main(String[] args) {
//        Test a = new Test(true);
//        Test b = new Test(false);
//
//        Thread t1 = new Thread(a);
//        Thread t2 = new Thread(b);
//
//        t1.start();
//        t2.start();
        Test a = new Test(true);
        Thread t1 = new Thread(a);
        Thread t2 = new Thread(a);
        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        a.setFlag(false);
        t2.start();
    }
}

（3）另一种方法就是申请锁的时候加上等待时间，如果等待时间到了还没拿到锁也不会被阻塞，相当于解决了死锁产生的第二个原因（死锁是默认阻塞的）。示例如下：

/**
 * 死锁解决方法之一：申请锁的时候加上等待时间.
 */
class Test implements Runnable
{
    private boolean flag;
    Lock locka = new ReentrantLock();
    Lock lockb = new ReentrantLock();
    Test(boolean flag)
    {
        this.flag = flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        if(flag)
        {
            while(true)
            {
                try {
                    locka.lock();
                    System.out.println(Thread.currentThread().getName()+" if locka.....");
                    if(lockb.tryLock(100, TimeUnit.MILLISECONDS)) {
                        try {
                            System.out.println(Thread.currentThread().getName()+" if lockb......");
                        }
                        finally {
                            lockb.unlock();
                        }
                    }
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                finally {
                    locka.unlock();
                }
            }
        }
        else
        {
            while(true)
            {
                try {
                    lockb.lock();
                    System.out.println(Thread.currentThread().getName()+" if locka.....");
                    if(locka.tryLock(100, TimeUnit.MILLISECONDS)) {
                       try {
                           System.out.println(Thread.currentThread().getName() + " if lockb......");
                       }
                       finally {
                           locka.unlock();
                       }
                    }
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                finally {
                    lockb.unlock();
                }
            }
        }
    }
}
class MyLock{
    public static final Object locka = new Object();
    public static final Object lockb = new Object();
}
public class DeadLock {
    public static void main(String[] args) {
        Test a = new Test(true);
        Thread t1 = new Thread(a);
        Thread t2 = new Thread(a);
        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        a.setFlag(false);
        t2.start();
    }
}

2.3 多线程通信

join()机制

  在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。
  对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。

public class JoinExample {
    private class A extends Thread {
        @Override
        public void run() {
            System.out.println("A");
        }
    }
    private class B extends Thread {
        private A a;
        B(A a) {
            this.a = a;
        }
        @Override
        public void run() {
            try {
                a.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("B");
        }
    }
    public void test() {
        A a = new A();
        B b = new B(a);
        b.start();
        a.start();
    }
}
public static void main(String[] args) {
    JoinExample example = new JoinExample();
    example.test();
}
输出结果为：
A
B

wait/notify机制

  调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。它们都属于 Object 的一部分，而不属于 Thread。
  使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。
  wait() 和 sleep() 的区别

• wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
• wait() 会释放锁，sleep() 不会。

  使用wait/notify机制时，要注意的是在“单生产者但消费者”模式的时候，仅用if与notify机制配合就行，因为不会存在多个生产者或消费者同时wait的情况，这样在被notify后就不用再次判断标记；在“多生产者多消费者”模式的情况下，需要用while和notifyAll配合，线程醒后还需要再判断标记。如果使用whlile和notify机制配合，可能会产生死锁，因为控制不了唤醒哪个具体的线程。示例如下：
  单生产者但消费者模式：

/**
 * 生产者和消费者问题（一个生产者一个消费者） if-notify()
 */
class Resource
{
    private String name;
    private int count;
    private boolean flag = false;
    public synchronized void set(String name)
    {
        if(flag)//flag为1，表示还没消费完
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name + count;
        count++;
        System.out.println(Thread.currentThread().getName()+" 生产者...... "+this.name);
        flag = true;
        notify();
    }
    public synchronized void out()
    {
        if(! flag)
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //this.name = name + count;
        //count--;
        System.out.println(Thread.currentThread().getName()+" 消费者............... " +this.name);
        flag = false;
        notify();
    }
}
class Producer implements Runnable
{
    private Resource resource;
    public Producer(Resource resource)
    {
        this.resource = resource;
    }
    @Override
    public void run() {
        while(true)
        {
            resource.set("烤鸭");
        }
    }
}
class Customer implements Runnable
{
    private Resource resource;
    public Customer(Resource resource)
    {
        this.resource = resource;
    }
    @Override
    public void run() {
        while(true)
        {
            resource.out();
        }
    }
}
public class ProducerAndCustomer {
    public static void main(String[] args) {
        Resource resource = new Resource();
        Producer producer = new Producer(resource);
        Customer customer = new Customer(resource);
        Thread t0 = new Thread(producer);
        Thread t1 = new Thread(customer);
        t0.start();
        t1.start();
    }
}