一、程序，进程和线程

1. 程序（Program）

是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。

2. 进程（Process）

程序的一次执行过程，或是正在运行的一个程序。说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

3. 线程（Thread）

进程可进一步细化为线程，是一个程序的一条执行路径。说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。

二、并行与并发

1. 单核CPU和多核CPU

在单核 cpu 下，线程实际还是串行执行的。操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows 下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是同时运行的。一般会将这种线程轮流使用 CPU 的做法称为并发（concurrent）。

多核 cpu下，每个核（core）都可以调度运行线程，这时候线程可以是并行（parallel）的，不同的线程同时使用不同的cpu在执行。

一个Java应用程序java.exe，其实至少三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

2.并行与并发的理解

并行(parallel)：多个CPU同时执行多个任务。比如：多个人同时做不同的事

并发(concurrent)：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事

为什么要使用多线程？

当我们在进行商品抢购的时候，在支付按钮上总是有个计时器在进行倒计时，但是我们此时仍然可以进行商品信息的查看，这个计时器和我们浏览商品信息的线程是同时进行的，这样也就实现了抢购场景，增加了用户的体验

多线程程序的优点

提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
提高计算机系统CPU的利用率。
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

应用的场景

程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
需要一些后台运行的程序时

三、Thread类

Java语言的JVM允许程序运行多个线程，它通过 java. lang.Thread类来体现注：所有的线程都是通过Thread类（或子类）启动

1. 创建多线程的方式

1.1 继承Thread类

创建一个继承于Thread类的子类，并重写run()方法

通过此对象调用start()

public class ThreadTest extends Thread{
 private static Integer ticket = 10;
 @Override
 public void run() {
     while (ticket > 0) {
         System.out.println(Thread.currentThread().getName() + ":" + "剩余" + ticket-- + "张");
     }
 }
 public static void main(String[] args) {
     ThreadTest thread1 = new ThreadTest();
     ThreadTest thread2 = new ThreadTest();
     thread1.start();
     thread2.start();
 }
}

3.2 实现Runnable接口的方式：

创建一个实现Runnable接口的类，并重写run()方法
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象

通过Thread类的对象调用start() ```java public class ThreadTest2 implements Runnable{

private static Integer ticket = 10;

@Override public void run() {

 while (ticket > 0) {
     System.out.println(Thread.currentThread().getName() + ":" + "剩余" + ticket-- + "张");
 }

}

public static void main(String[] args) {

 ThreadTest2 thread1 = new ThreadTest2();

 Thread t2 = new Thread(thread1);
 t2.setName("t2");
 t2.start();

 Thread t1 = new Thread(thread1);
 t1.setName("t1");
 t1.start();

} }

// 匿名内部类 new Thread(new Runnable() { @Override public void run() { while (ticket > 0) { System.out.println(Thread.currentThread().getName() + “:” + “剩余” + ticket— + “张”); } } }, “t1”);

// lambda表达式方式（推荐） Thread thread = new Thread(() -> { while (ticket > 0) { System.out.println(Thread.currentThread().getName() + “:” + “剩余” + ticket— + “张”); } }, “t1”);


<a name="oU7jj"></a>
#### 3.3  FutureTask 配合 Thread

1. 创建一个实现Callable的实现类，并实现call方法
1. 将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
1. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
1. 获取Callable中call方法的返回值
```java
public static void main(String[] args) throws ExecutionException, InterruptedException {
    // 实现多线程的第三种方法可以返回数据
    FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            Thread.sleep(100);
            return 100;
        }
    });
    // 主线程阻塞，同步等待 task 执行完毕的结果
    new Thread(futureTask,"t1").start();
    System.out.println(futureTask.get());
}

// lambda表达式方式（推荐）
public static void main(String[] args) throws ExecutionException, InterruptedException {
    FutureTask<Integer> futureTask = new FutureTask<>(() -> {
        TimeUnit.SECONDS.sleep(1);
        return 100;
    });
    new Thread(futureTask, "t1").start();
    System.out.println(futureTask.get());
}

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？

1. call()可以返回值
2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
3. Callable是支持泛型的

3.4 使用线程池（推荐）

JDK 5.0起提供了线程池相关AP|： Executor Service和 Executors

Executor Service：真正的线程池接口。常见子类 Thread Poolexecutor
void execute(Runnable command）：执行任务/命令，没有返回值，一般用来执行Runnable
Future submit（Callabletask）：执行任务，有返回值，一般又来执行Callable
void shutdown()：关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
Executors.newFⅸedthreadPool(n)；创建一个可重用固定线程数的线程池
EXecutors.newSingleThreadEXecutor()：创建一个只有一个线程的线程池
Executors.new threadPoo(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

应用线程池的好处：

1.提高响应速度（减少了创建新线程的时间）

2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）

3.便于线程管理
    corePoolSize：核心池的大小
    maximumPoolSize：最大线程数
    keepAliveTime：线程没任务时最多保持多长时间后会终止

2. 线程运行原理*

虚拟机栈与栈帧

虚拟机栈描述的是Java方法执行的内存模型：每个方法被执行的时候都会同时创建一个栈帧(stack frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息，是属于线程的私有的。当java中使用多线程时，每个线程都会维护它自己的栈帧！每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

线程上下文切换（Thread Context Switch）

因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码

线程的 cpu 时间片用完(每个线程轮流执行，看前面并行的概念)
垃圾回收
有更高优先级的线程需要运行
线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

3. Thread类的常用方法

构造方法：

public Thread()

public Thread(String name)

public Thread(Runnable target)

public Thread(Runnable target, String name)

start与run

直接调用 run 是在主线程中执行了 run，没有启动新的线程
使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

sleep(sec)

Thread类的本地静态方法，调用后能使线程由运行状态Running进入休眠阻塞状态Timed Waiting。
入参为休眠时间，单位为毫秒，超过休眠时间后，线程会由休眠阻塞状态Timed Waiting进入就绪状态Runnable，等待CPU时间片重新进入运行状态。
不会释放当前线程所持有的的对象的锁。
sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
建议用 TimeUnit 的 sleep() 代替 Thread 的 sleep()来获得更好的可读性。

yield

Thread类的本地静态方法，调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
不会释放当前线程所持有的的对象的锁。

join

用于等待某个线程结束。哪个线程内调用join()方法，就等待哪个线程结束，然后再去执行其他线程。
如在主线程中调用ti.join()，则是主线程等待t1线程结束，join 采用同步。

public class ThreadTest extends Thread {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("进入线程");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程开始执行");
        });
        t1.start();
        t1.join(1000);
        System.out.println("主线程开始执行");
    }
}

中断

中断一个线程（设置标志位）

1、如果线程处于阻塞状态（例如处于 sleep, wait, join 等状态），那么线程将立即退出阻塞状态，并抛出一个 InterruptedException 异常，仅此而已，中断标记仍为 false。

public class ThreadTest extends Thread {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("sleep....");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("interrupt");
        thread.interrupt();
        System.out.println("打断标记" + thread.isInterrupted());
    }

}

结果：
sleep....
interrupt
打断标记false
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at java.lang.Thread.sleep(Thread.java:340)
    at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
    at org.inter.java.ThreadTest.lambda$main$0(ThreadTest.java:14)
    at java.lang.Thread.run(Thread.java:748)

Process finished with exit code 0


2、如果线程处于正常活动状态，那么会将该线程的中断标志设置为 true，仅此而已，不会抛出异常。被设置中断标志的线程将继续正常运行，不受影响。

public class ThreadTest extends Thread {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("Thread running...");
             while (true) {

             }
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("interrupt");
        thread.interrupt();
        System.out.println("打断标记" + thread.isInterrupted());
    }

}

结果：
Thread running...
interrupt
打断标记true

综上所述，interrupt() 方法并不能真正的中断线程，需要被调用的线程自己进行处理才行。

用来返回线程的中断状态，调用这一方法不会改变线程的中断状态，类似“get”。

public class MyThread extends Thread{
    @Override
    public void run() {
        while (!this.isInterrupted())
        {
            System.out.println("当前线程没有被中断，继续干活");
        }
        System.out.println("当前线程被被中断，停止干活");
    }
}

源码如下：
public boolean isInterrupted() {
    //继调用isInterrupted方法，只不过参数传递false
    return isInterrupted(false);
}

Thead类的静态方法，返回线程的中断状态，同时会将线程的中断状态置为false，类似“get”+"set"。

源码如下：
public static boolean interrupted() {
    //调用了当前线程的isInterrupted方法，参数传递true
    return currentThread().isInterrupted(true);
}

isInterrupted() 和 interrupted() 最终调用的 isInterrupted() 方法源码如下：

//是一个本地方法
private native boolean isInterrupted(boolean ClearInterrupted);

通过参数名可以得知参数的作用是是否要清除状态位。

如果这个参数为true，表示要清除线程的状态标志，也就是置为false；如果参数为false，直接返回线程的状态位，不会对状态进行修改。

终止模式之两阶段终止模式

线程的isInterrupted()方法可以取得线程的打断标记，如果线程在睡眠sleep期间被打断，打断标记是不会变的，为false，但是sleep期间被打断会抛出异常，我们据此手动设置打断标记为true；如果是在程序正常运行期间被打断的，那么打断标记就被自动设置为true。处理好这两种情况那我们就可以放心地来料理后事啦！

两阶段终止模式简单的说，就是让线程在阻塞和非阻塞状态下都能正常“料理后事”。

@Slf4j
public class Test11 {
    public static void main(String[] args) throws InterruptedException {
        TwoParseTermination twoParseTermination = new TwoParseTermination();
        twoParseTermination.start();
        Thread.sleep(3000);  // 让监控线程执行一会儿
        twoParseTermination.stop(); // 停止监控线程
    }
}


@Slf4j
class TwoParseTermination{
    Thread thread ;
    public void start(){
        thread = new Thread(()->{
            while(true){
                if (Thread.currentThread().isInterrupted()){
                    log.debug("线程结束。。正在料理后事中");
                    break;
                }
                try {
                    Thread.sleep(500);
                    log.debug("正在执行监控的功能");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    e.printStackTrace();
                }
            }
        });
        thread.start();
    }
    public void stop(){
        thread.interrupt();
    }
}

sleep，yiled，wait，join 对比

补充：

sleep，join，yield，interrupted是Thread类中的方法
wait/notify是object中的方法

sleep 不释放锁、释放cpu join 释放锁、抢占cpu yiled 不释放锁、释放cpu wait 释放锁、释放cpu

4. 线程状态

线程状态之五种状态

五种状态的划分主要是从操作系统的层面进行划分的

初始状态，仅仅是在语言层面上创建了线程对象，即Thead thread = new Thead();，还未与操作系统线程关联
可运行状态，也称就绪状态，指该线程已经被创建，与操作系统相关联，等待cpu给它分配时间片就可运行
运行状态，指线程获取了CPU时间片，正在运行
1. 当CPU时间片用完，线程会转换至【可运行状态】，等待 CPU再次分配时间片，会导致我们前面讲到的上下文切换
阻塞状态
1. 如果调用了阻塞API，如BIO读写文件，那么线程实际上不会用到CPU，不会分配CPU时间片，会导致上下文切换，进入【阻塞状态】
2. 等待BIO操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
3. 与【可运行状态】的区别是，只要操作系统一直不唤醒线程，调度器就一直不会考虑调度它们，CPU就一直不会分配时间片
终止状态，表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

线程状态之六种状态

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,(新建)

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,（就绪/可运行）

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,（阻塞）

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,（等待）

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,（限时等待）

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;（终止）
    }

四、线程的同步机制

在Java中，我们通过同步机制，来解决线程的安全问题。

1. 同步代码块

synchronized(同步监视器){//同步监视器就是需要同步线程的公共对象
   //需要被同步的代码
}

说明：

1.操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。
2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
4.要求多个线程必须要共用同一把锁。

注意：
1.在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
2.在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

举例1：

public class Ticket implements Runnable {
    private int tick = 100;

    @Override
    public void run() {

        while (true) {
            synchronized (this) {
                if (tick > 0) {
                    System.out.println(Thread.currentThread().getName() + "号窗口买票，票号为：" + tick--);
                } else {
                    break;
                }
            }
        }
    }
}

class TicketTest {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        Thread thread1 = new Thread(ticket);
        Thread thread2 = new Thread(ticket);
        Thread thread3 = new Thread(ticket);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();

    }
}

举例2:

public class Ticket2 extends Thread {
    private static int tick = 100;
    private static Object object = new Object();

    public Ticket2() {
    }

    @Override
    public void run() {

        while (true) {
            synchronized (object) {
            //synchronized (Ticket2.class) {//通过反射调用当前类
                if (tick > 0) {
                    System.out.println(Thread.currentThread().getName() + "号窗口买票，票号为" + tick--);
                } else {
                    break;
                }
            }

        }
    }
}

class TicketTest2 {
    public static void main(String[] args) {
        Ticket2 ticket1 = new Ticket2();
        Ticket2 ticket2 = new Ticket2();
        Ticket2 ticket3 = new Ticket2();

        ticket1.setName("窗口1");
        ticket2.setName("窗口2");
        ticket3.setName("窗口3");

        ticket1.start();
        ticket2.start();
        ticket3.start();


    }
}

2. 同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

public synchronized void show(String namer){
....
}


public class Ticket3 implements Runnable {
    private int tick = 100;
    private boolean isFlag = true;

    @Override
    public void run() {
        while (isFlag) {
            show();
        }
    }

    public synchronized void show() {//同步show方法，继承Thread类方法一样，只需同步方法即可，同时需要给方法加static关键字，确保不会创建多个对象
        if (tick > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "号窗口买票，票号为：" + tick--);
        } else {
            isFlag = false;
        }
    }
}

class TicketTest3 {
    public static void main(String[] args) {
        Ticket3 ticket = new Ticket3();

        Thread thread1 = new Thread(ticket);
        Thread thread2 = new Thread(ticket);
        Thread thread3 = new Thread(ticket);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();

    }
}

3. Lock锁 —- JDK 5.0新增

1.从JDK 5.0开始，Java提供了更强大的线程同步机制--通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
2.java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
3.ReentrantLock类实现了Lock，它拥有与 synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 Reentrantlock，可以显式加锁、释放锁。

class A {
    //1.实例化ReentrantLock对象
    private final ReenTrantLock lock = new ReenTrantLook();
    public void m (){
        lock.lock//2.先加锁
        try{
            //保证线程同步的代码
        }finally{
            lock.unlock();//3.后解锁
        }
    }
}

//注意：如果同步代码块有异常，要将unlock()写入finally语句块中

举例：
class Window implements Runnable{

    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try{

                //2.调用锁定方法lock()
                lock.lock();

                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }

        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

4. 面试题

synchronized 与 Locd的异同？

相同：二者都可以解决线程安全问题
不同：synchornized机制在执行完相应的代码后，自动的释放同步监视器 ; Lock需要手动启动同步（lock()，同时结束同步也需要手动的实现unlock()）

5. 线程安全的单例模式

class Bank{

    private Bank(){}

    private static Bank instance = null;

    public static Bank getInstance(){
        //方式一：效率稍差
//        synchronized (Bank.class) {
//            if(instance == null){
//
//                instance = new Bank();
//            }
//            return instance;
//        }
        //方式二：效率更高
        if(instance == null){
            synchronized (Bank.class) {
                if(instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

6. 死锁

死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
说明：

出现死锁后，不会出现异常，不会出现提示，只是所的线程都处于阻塞状态，无法继续
我们使用同步时，要避免出现死锁。

public static void main(String[] args) {

    StringBuffer s1 = new StringBuffer();
    StringBuffer s2 = new StringBuffer();

    new Thread(){
        @Override
        public void run() {

            synchronized (s1){

                s1.append("a");
                s2.append("1");

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (s2){
                    s1.append("b");
                    s2.append("2");

                    System.out.println(s1);
                    System.out.println(s2);
                }
            }
        }
    }.start();


    new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (s2){

                s1.append("c");
                s2.append("3");

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (s1){
                    s1.append("d");
                    s2.append("4");

                    System.out.println(s1);
                    System.out.println(s2);
                }
            }
        }
    }).start();
}

五、线程通讯

为了解决线程的死锁问题，引入线程通讯

1. 线程通讯主要涉及三个方法

wait() ：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify() ：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
notifyAll() ：一旦执行此方法，就会唤醒所有被wait的线程。

2. 说明：

wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常
wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。

class MyThread implements Runnable {
    private int number = 1;
    private Object object = new Object();

    @Override
    public void run() {
        while (true) {

            synchronized (object) {
                object.notify();//调用notify()方法唤醒线程
                if (number <= 100) {
                    //线程休眠
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + number);
                    number++;

                    try {
                        object.wait();//打印输出一次后调用wait()方法将线程阻塞
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

public class CommunicationTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        Thread thread1 = new Thread(myThread);
        Thread thread2 = new Thread(myThread);

        thread1.setName("线程1:");
        thread2.setName("线程2:");

        thread1.start();
        thread2.start();
    }
}

public class ProductTest {

    public static void main(String[] args) {
        Clark clark = new Clark();
        Producer producer = new Producer(clark);
        Consumer consumer = new Consumer(clark);

        Thread t1 = new Thread(producer);
        t1.setName("producer1: ");

        Thread t3 = new Thread(consumer);
        Thread t4 = new Thread(consumer);
        t3.setName("consumer1: ");
        t4.setName("consumer2: ");

        t1.start();
        t3.start();
        t4.start();
    }
}

class Clark {

    public Integer product = 0;

    public synchronized void produce() {
        if (product >= 20) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println(Thread.currentThread().getName() + "生产了1个产品");
            product++;
            notify();

        }
    }

    public synchronized void consumer() {
        if (product <= 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println(Thread.currentThread().getName() + "消费了1个产品");
            product--;
            notify();
        }
    }

}

class Producer implements Runnable {

    private Clark clark;

    public Producer(Clark clark) {
        this.clark = clark;
    }

    @Override
    public void run() {
        while (true) {
            System.out.println("开始生产产品。。。");
            clark.produce();
        }
    }
}

class Consumer implements Runnable {

    private Clark clark;

    public Consumer(Clark clark) {
        this.clark = clark;
    }

    @Override
    public void run() {
        while (true) {
            System.out.println("开始消费产品。。。");
            clark.consumer();
        }
    }
}

sleep() 和 wait()的异同？
相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点：
1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁

3. 释放锁的操作

当前线程的同步方法、同步代码块执行结束
当前线程在同步代码块、同步方法中遇到 break、 return终止了该代码块该方法的继续执行。
当前线程在同步代码块、同步方法中出现了未处理的Error或 Exception，导致异常结束。
当前线程在同步代码块、同步方法中执行了线程对象的 wait()方法，当前线程暂停，并释放锁

4. 不会释放锁的操作

线程执行同步代码块或同步方法时，程序调用 Thread. sleep()、Thread yield()方法暂停当前线程的执行
线程执行同步代码块时，其他线程调用了该线程的 suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）
应尽量避免使用 suspend()和 resume()来控制线程

线程概述