1、线程的相关概念

程序

为了让计算机完成某个特定的功能，而编写的一系列的有序指定的集合。即：一段静态的代码。

进程

正在运行的程序。即：动态的过程，有自己的产生、存在和消亡。

线程

一个进程可以划分为若干个小的执行单位，每一个执行单位，就是线程。
一个进程可以包含多个线程。
若一个程序可以在同一时间执行多个线程，就是支持多线程的。

多任务

同一时刻，好像同时执行多个任务（进程）。比如Windows操作系统就是多任务操作系统。多任务可以理解为多进程。

2、多线程

<h2>概念</h2>

同一时刻，好像同时执行多个线程。
每个Java程序都有一个隐含的主线程：main方法。

多线程的执行

多个线程轮流抢占CPU时间片，因为速度非常快，所以造成了多个线程同时执行的错觉。

使用的好处

⑴ 有效的占用了CPU的资源，从某种意义上来讲提高了效率。
⑵ 提高了用户体验性。

应用场景

⑴ 程序需要同时执行两个或多个任务。
⑵ 程序需要实现一些等待的任务，比如：用户输入、文件读写操作、网络操作、搜索等。
⑶ 程序需要后台一直完成某项操作。

3、Thread类

Java语言使用Thread类及其子类的对象来表示线程。

4、Thread类的构造方法

Thread()

public Thread() {}
构造一个Thread对象。

<h2>Thread(String name)</h2>
  public Thread(String name) {}
  构造一个Thread对象，同时指定线程的名字。

Thread的子类可以通过调用super(String name); 来设置线程的名字。

<h2>Thread(Runnable target, String name)</h2>
  public Thread(Runnable target, String name) {}
  构造一个Thread对象，需要传入一个Runnable的实现类，同时指定该线程的名字。

5、线程的创建和启动

继承Thread

⑴ 定义一个类，让其继承Thread类，再重写run方法。
⑵ 创建继承Thread的类的对象，并调用对象的start方法。

 class MyThread extends Thread {
   @Override
   public void run() {
     // 任务体
   }
 }

 MyThread mt = new MyThread();
 mt.start();

实现Runnable接口

⑴ 定义一个类，让其实现Runnable接口，再实现run方法。
⑵ 创建一个Thread对象，将实现Runnable接口的实现类的对象传入Thread的构造方法。
⑶ 调用Thread对象的start方法。

 class MyRunnable implements Runnable {
   @Override
   public void run() {
     // 任务体
   }
 }

  MyRunnable mr = new MyRunnable();
  Thread t = new Thread(mr);
  t.start();

对比

相同点

⑴ 任务体都写在run方法中
⑵ 都调用了的Thread类（本类或子类）的start方法来启动线程

  <h3>不同点</h3>
   相对于继承Thread类，实现Runnable接口：
    ⑴ 避免了单继承的局限性，更加灵活
    ⑵ 比较适合解决多个线程共享数据资源的情况

    <h4>卖票【多个线程共享数据资源】</h4>

public class Test {
public static void main(String[] args) {
WindowRunnable wr = new WindowRunnable();
Thread t1 = new Thread(wr, “窗口1”);
Thread t2 = new Thread(wr, “窗口2”);
Thread t3 = new Thread(wr, “窗口3”);
t1.start();
t2.start();
t3.start();
}
}

class WindowRunnable implements Runnable {
private int tickets = 100; // 总票数
@Override
public void run() {
for (;;) {
if (0 < tickets) {
System.out.println(Thread.currentThread().getName() + “卖出了一张票，剩余票数：” + (–tickets));
} else {
System.out.println(Thread.currentThread().getName() + “票卖完了！”);
break;
}
}
}
}

6、Thread类的方法列举

start

public synchronized void start() {}
启动线程，并执行对应的run方法。

run

public void run() {}
子线程要执行的代码，要放入重写（实现）的此方法中。

currentThread

public static native Thread currentThread();
获取当前正在执行的线程对象。静态方法，通过Thread来调用。

setName

public final void setName(String name) {}
设置线程的名称。

getName

public final String getName() {}
获取线程的名称。

 <h3>设置和获取线程名称【Thread的子类】</h3>

public class Test {
public static void main(String[] args) {
MyThread mt1 = new MyThread();
mt1.start(); // Thread-0 【默认线程名字从0开始】
MyThread mt2 = new MyThread(“线程2”);
mt2.start(); // 线程2
MyThread mt3 = new MyThread();
mt3.setName(“线程3”); // 调用设置线程名称的方法
mt3.start(); // 线程3
}
}

class MyThread extends Thread {
public MyThread() {
}

public MyThread(String name) { // 添加有参构造
super(name); // 调用父类【Thread】的构造方法
}

@Override
public void run() {
// 因为该线程类继承了Thread，所以可以直接调用【省略了this 完整：this.getName()】
System.out.println(getName());
}
}

 <h3>设置和获取线程名称【Runnable的实现类】</h3>

public class Test {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr, “线程1”); // 设置线程名称
Thread t2 = new Thread(mr, “线程2”); // 设置线程名称
t1.start(); // 线程1
t2.start(); // 线程2
}
}

class MyRunnable implements Runnable {
@Override
public void run() {
// 通过调用Thread的静态方法获取当前线程对象，再调用方法获取线程名称
System.out.println(Thread.currentThread().getName());
}
}

setPriority

public final void setPriority(int newPriority) {}
设置线程的优先级。需要传入一个int类型的优先级。优先级范围1-10。注意：不能超过最高优先级【10】或低于最高优先级【1】，否则报错。看源码：

    if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
        throw new IllegalArgumentException();
    }

  Thread类中有三个常量：

public final static int MIN_PRIORITY = 1; // 最低优先级
public final static int NORM_PRIORITY = 5; // 默认优先级
public final static int MAX_PRIORITY = 10; // 最高优先级

注意：<b>优先级高的线程不一定先执行完，它只是具有CPU抢占的优先权。</b>

getPriority

public final int getPriority() {}
返回线程的优先级。

sleep

public static native void sleep(long millis) throws InterruptedException;
让当前线程休眠（暂停执行）指定的毫秒数。静态方法，通过Thread来调用。

 <h3>设置和获取线程的优先级并测试执行的优先级</h3>

public class Test {
public static void main(String[] args) {
MyThread mt1 = new MyThread(“最高优先级线程”);
mt1.setPriority(Thread.MAX_PRIORITY); // 设置最高优先级【10】
mt1.start();
MyThread mt2 = new MyThread(“默认优先级线程”);
mt1.setPriority(Thread.NORM_PRIORITY); // 设置默认优先级【5】
mt2.start();
MyThread mt3 = new MyThread(“最低优先级线程”);
mt3.setPriority(Thread.MIN_PRIORITY); // 设置最低优先级【1】
mt3.start();
}
}

class MyThread extends Thread {
public MyThread(String name) {
super(name);
}

@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(300); // 休眠线程300毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}

  System.out.println(getName() + "被执行了");
}

}
}

可以看出最终的执行效果具有随机性，所以可以验证：
① 优先级高的线程不一定先执行完，它只是具有CPU抢占的优先权。
② CPU抢占的优先权是随机的。

isAlive

public final native boolean isAlive();
测试线程是否处于活动状态。

isInterrupted

public boolean isInterrupted() {}
测试线程是否已经中断。

interrupt

public void interrupt() {}
中断线程，但实际上并没有真正停止线程。方法的本质：给线程添加一个中断的标记。

注意

如果中断的是正在休眠的线程，则会执行try住Thread.sleep(long millis); 方法中的catch块中的语句【可能是错误：java.lang.InterruptedException: sleep interrupted 或 自定义代码】。

示例：
public class Test {
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.start();
mt.interrupt(); // 添加中断标记
}
}

class MyThread extends Thread {
@Override
public void run() {
try {
Thread.sleep(1000); // 线程休眠1000毫秒
} catch (InterruptedException e) {
// e.printStackTrace();
System.out.println(“我就是被执行的文字！”);
}
}
}

理解

给线程添加一个中断的标记，可以配合isInterrupted方法来使用。

示例：
public class Test {
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.start();

try {
  Thread.sleep(50); // 主线程休眠（暂停执行）50毫秒
} catch (InterruptedException e) {
  e.printStackTrace();
}
mt.interrupt(); // 添加中断标记

}
}

class MyThread extends Thread {
@Override
public void run() {
for (;;) {
System.out.println(“线程任务打印文字”);
if (this.isInterrupted()) { // 判断是否已经添加中断标记
break; // 跳出循环
}
}
System.out.println(“============任务结束了============”);
}
}

yield

public static native void yield();
暂停当前正在执行的线程对象，并执行其他线程。静态方法，通过Thread来调用。
注意：让出CPU的占用权，但是让出的时间具有不确定性。不一定让出CPU占用权的线程最后执行完。

  <h3>查看其中一个线程暂停后的执行结果</h3>

public class Test {
public static void main(String[] args) {
MyThread1 mt1 = new MyThread1();
mt1.setName(“线程1”);
MyThread2 mt2 = new MyThread2();
mt2.setName(“线程2”);
MyThread3 mt3 = new MyThread3();
mt3.setName(“线程3”);
mt1.start();
mt2.start();
mt3.start();
}
}

class MyThread1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
if (10 == i) {
Thread.yield(); // 暂停当前线程
System.out.println(“==========暂停” + getName() + “==========”);
}

  System.out.println(getName() + "被执行");
}

System.out.println("==========" + getName() + "执行完毕！==========");

}
}

class MyThread2 extends Thread {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(getName() + “被执行”);
}
}
}

class MyThread3 extends Thread {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(getName() + “被执行”);
}
}
}

join

public final void join() throws InterruptedException {}
让线程抢占CPU的时间片。一旦抢到，该线程肯定会被执行完。
应用于当一个线程需要调用另一个线程的执行结果，而另一个线程并未执行完毕，这时就可以调用此方法，以便获取执行的结果。

  <h3>主线程获取另外一子线程的执行结果</h3>

public class Test {
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.start();
for (int i = 0; i < 10; i++) {
System.out.println(mt.sum); // 获取求和的结果
}

try {
  System.out.println("让mt线程获取CPU时间片, 请耐心等待结果的输出。。。");
  mt.join(); // 调用join方法，让mt线程获取CPU时间片【若不让mt线程抢占CPU时间片，则主线程打印结果会是0】
} catch (InterruptedException e) {
  e.printStackTrace();
}
System.out.println("1-100的和为：" + mt.sum); // 输出求和的结果

}
}

class MyThread extends Thread {
int sum; // 求和结果
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
try {
Thread.sleep(15);
} catch (InterruptedException e) {
e.printStackTrace();
}

  sum += i;
}

}
}

setDaemon

public final void setDaemon(boolean on) {}
将该线程标记为守护线程或用户线程。true为守护线程，false为用户线程。

线程的分类

用户线程
守护线程

<h4>区别</h4>
     线程的执行是否要结束的方式

 ⑴ 用户线程有2种方式：
   ① 正常结束（任务执行完毕）
   ② 被中断

     ⑵ 守护线程只有1中方式：
        用户线程执行结束
     注意：如果用户线程已经执行结束，这时不管守护线程有没有结束，其都要结束。

    <h4>JDK中典型的守护线程</h4>
       垃圾回收机制

  <h3>守护线程随着主线程的结束而结束</h3>

public class Test {
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.setDaemon(true); // 设置为守护线程
mt.start();

for (int i = 0; i < 10; i++) {
  try {
    Thread.sleep(10);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }

  System.err.println("主线程执行");
}
System.err.println("==========主线程执行完毕==========");

}
}

class MyThread extends Thread {
@Override
public void run() {
for (;;) {
try {
Thread.sleep(40);
} catch (InterruptedException e) {
e.printStackTrace();
}

  System.out.println("-----守护线程执行任务-----");
}

}
}

7、线程的停止

实现方法

⑴ 调用线程类的stop方法。但该方法已经过时（@Deprecated），不建议使用。
⑵ 调用线程类的interrupt方法。但是不能真正的停止。
⑶ 采用通知的方式。该方式可确保线程以安全的方式结束运行，建议使用。

  <h3>通知方式的实现步骤</h3>
    ⑴ 在线程类中添加一个boolean类型的循环标记，默认为true。
    ⑵ 在线程类中的run方法中，添加一个循环，循环条件为刚才添加的boolean类型的循环标记。
    ⑶ 在线程类中添加一个更新循环标记的方法。
    ⑷ 在需要停止线程时，将循环标记改为false即可。

public class Test {
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.start();

try {
  Thread.sleep(50); // 主线程休眠（暂停执行）50毫秒
} catch (InterruptedException e) {
  e.printStackTrace();
}
mt.setLoop(false); // 更新循环标记

}
}

class MyThread extends Thread {
private boolean loop = true; // 循环标记

@Override
public void run() {
while (loop) { // 循环条件为循环标记
System.out.println(“线程任务打印文字”);
}
System.out.println(“============任务结束了============”);
}

public void setLoop(boolean loop) { // 更新循环标记的方法
this.loop = loop;
}
}

8、线程的生命周期

新建 —— 就绪 —— 运行 —— 阻塞 —— 死亡

新建

创建线程对象

就绪

调用了start方法
注意：调用此方法的线程将会进入线程队列等待CPU时间片，它只是具备了运行的条件。

运行

抢到了CPU的执行权
线程的run方法定义了线程的操作和功能。

阻塞

调用了sleep方法，或wait方法
在某种特殊的情况下，被人为挂起或输入输出操作时，让出CPU，并临时中止。

死亡

线程任务正常执行完毕，或异常停止

9、线程的同步

问题的产生

多个线程，共同操作同一个数据资源时，有可能其中一个线程还没有执行完毕，而另外一个线程参与进来。这样就会导致数据出现了脏读。这就是线程同步问题。

解决办法

对多条操作共享数据的语句，只能让一个线程都执行完，其他的线程再参与进来。在其中一个线程执行过程中，其他线程不可以参与执行。

  具体就是：将需要共同操作的代码，上个“锁”。

互斥锁

Java中引入了对象互斥锁的概念，来保证共享数据操作的完整性。
每一个对象都对应一个可以称为“互斥锁”的标记。这个标记用来保证在任一时刻，只能有一个线程对象访问该对象。

  <h3>synchronized关键字</h3>
    用synchronized关键字来与对象的互斥锁联系。<b>当某个对象用synchronized修饰时，表明该对象在任一时刻只能有一个线程访问。</b>

 <h3>同步代码块</h3>
    synchronized(对象) { // 对象就是“锁”
      // 需要被同步的代码
    }

 <h3>同步方法</h3>
 修饰符 synchronized 返回值类型 方法名(形参列表) {
   // 需要被同步的代码
 }

  整个方法为同步方法。
注意：

⑴ 需要同步的代码一般里面没有循环。
⑵
① 普通的同步方法默认的锁对象为：this
② 静态的同步方法默认的锁对象为：当前类.class

实现步骤

⑴ 找到需要同步的代码【多个线程共同操作的代码】。
⑵ 添加同步代码块或同步方法。
⑶ 判断锁对象是否为同一个

释放锁的操作

⑴ 当前线程的同步代码块、同步方法执行完毕。
⑵ 当前线程在同步代码块、同步方法中遇到break或return终止了该代码块、方法的继续执行。
⑶ 当前线程在同步代码块、同步方法中出现了Error或Exception，导致异常结束。
⑷ 当前线程在同步代码块、同步方法中执行了线程对象的wait 方法。会使当前线程暂停，并释放互斥锁。

不会释放锁的操作

当某线程执行同步代码块、同步方法时，程序调用了Thread.sleep()【休眠线程】 或 Thread.yield()【暂停线程，让出CPU的抢占权】，暂停了当前线程的执行。这并不会释放互斥锁。

同步的前提

⑴ 有多个线程。
⑵ 多个线程有共享的数据。
⑶ 多个线程都有操作共享数据的代码。

同步的局限性

在一定程度上降低了程序的执行效率。

使用示例

不使用同步来卖票【出现了线程同步问题】

public class Test {
public static void main(String[] args) {
WindowRunnable wr = new WindowRunnable();
Thread t1 = new Thread(wr, “窗口1”);
Thread t2 = new Thread(wr, “窗口2”);
Thread t3 = new Thread(wr, “窗口3”);
t1.start();
t2.start();
t3.start();
}
}

class WindowRunnable implements Runnable {
private int tickets = 100; // 总票数
@Override
public void run() {
for (;;) {
if (0 < tickets) {
try {
Thread.sleep(10); // 让当前线程休眠10毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}

      System.out.println(Thread.currentThread().getName() + "卖出了一张票，剩余票数：" + (--tickets));
  } else {
      System.out.println(Thread.currentThread().getName() + "票卖完了！");
      break;
  }
}

}
}

可以看出最终的结果存在负数，所以出现了线程同步问题。

使用同步来卖票【解决线程同步问题】

public class Test {
public static void main(String[] args) {
WindowRunnable wr = new WindowRunnable();
Thread t1 = new Thread(wr, “窗口1”);
Thread t2 = new Thread(wr, “窗口2”);
Thread t3 = new Thread(wr, “窗口3”);
t1.start();
t2.start();
t3.start();
}
}

class WindowRunnable implements Runnable {
private int tickets = 100; // 总票数
private boolean loop = true; // 循环标记

private synchronized void sellTickets() { // 同步方法
if (0 < tickets) {
try {
Thread.sleep(10); // 让当前线程休眠10毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}

    System.out.println(Thread.currentThread().getName() + "卖出了一张票，剩余票数：" + (--tickets));
  } else {
    System.out.println(Thread.currentThread().getName() + "票卖完了！");
    loop = false;
 }

}

@Override
public void run() {
while (loop) {
sellTickets();

 /* 同步代码块
  synchronized(this) {
    if (0 < tickets) {
        try {
          Thread.sleep(10); // 让当前线程休眠10毫秒
        } catch (InterruptedException e) {
          e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + "卖出了一张票，剩余票数：" + (--tickets));
    } else {
        System.out.println(Thread.currentThread().getName() + "票卖完了！");
        break;
    }
  }
   */
}

}

}

解决单例模式（懒汉式）的线程同步问题

  <h3>旧的代码【线程同步问题】</h3>

public class Test {
public static void main(String[] args) {
PrintThread pt1 = new PrintThread();
PrintThread pt2 = new PrintThread();
pt1.start();
pt2.start();
}
}

class PrintThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + Singleton.getInstance());
}
}
}

class Singleton {
private Singleton(){}

private static Singleton instance;

public static Singleton getInstance() {
if (null == instance) {
instance = new Singleton();
}
return instance;
}
}

可以看到：之前的代码，如果在多个线程中运行，会发现创建出的对象不是唯一的。

  <h3>修改后的单例模式【解决线程同步问题】</h3>

public class Test {
public static void main(String[] args) {
PrintThread pt1 = new PrintThread();
PrintThread pt2 = new PrintThread();
pt1.start();
pt2.start();
}
}

class PrintThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + Singleton.getInstance());
}
}
}

class Singleton {
private Singleton(){}

private static Singleton instance;

public static Singleton getInstance() {
if (null == instance) { // 提高效率
synchronized(Singleton.class) { // 同步代码块
if (null == instance) {
instance = new Singleton();
}
}
}

return instance;

}
}

10、线程的通信

概念

多个线程之间可以进行通话。

例如：开启了两个线程来打印100以内的数字，结果可能会是：
A 1
A 2
B 3
B 4
B 5
…

 而我们希望是：
      A  1
      B  2
      A  3
      B  4
      ...
  这种交替打印的效果
  这时就需要使用线程的通信

常见方法

wait

public final native void wait(long timeout) throws InterruptedException;
使某个同步代码块或同步方法中的当前线程进入等待状态，直到另外一线程对该线程发出notify或notifyAll为止。该方法只能被锁对象【同步代码块或同步方法的互斥锁（唯一性）】执行。
注意：
⑴ 该方法在Object类中，即每个对象类都有。
⑵ 调用此方法后，当前线程会释放对象监控权（互斥锁），然后进入等待。
⑶ 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁了）【线程必须可以执行同步方法、或同步代码块中的代码（被锁包起来）】。
⑷ 当线程被notify后，重新获取监控权（互斥锁），这时会从断点处【被wait的地方】继续执行。

  <h3>notify</h3>
    public final native void notify();
    唤醒某个同步代码块或同步方法中的被wait的一个线程。<b>该方法只能被锁对象【同步代码块或同步方法的互斥锁（唯一性）】执行。</b>
 注意：

⑴ 该方法在Object类中，即每个对象类都有。
⑵ 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁了）【线程必须可以执行同步方法、或同步代码块中的代码（被锁包起来）】。

  <h3>notifyAll</h3>
    public final native void notifyAll();
    唤醒某个同步代码块或同步方法中的被wait的所有线程。唤醒的顺序是随机的。<b>该方法只能被锁对象【同步代码块或同步方法的互斥锁（唯一性）】执行。</b>
 注意：

⑴ 该方法在Object类中，即每个对象类都有。
⑵ 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁了）【线程必须可以执行同步方法、或同步代码块中的代码（被锁包起来）】。

使用示例

  <h3>两个线程交错打印1-100内的数</h3>

public class Test {
public static void main(String[] args) {
PrintNum pn = new PrintNum();
Thread t1 = new Thread(pn, “打印者一”);
Thread t2 = new Thread(pn, “打印者二”);
t1.start();
t2.start();
}
}

class PrintNum implements Runnable {
private int num = 0;

@Override
public void run() {
for (;;) {
synchronized (this) {
this.notify(); // 在此唤醒上次打印过的线程

        if (num < 100) {
          try {
            Thread.sleep(26);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println(Thread.currentThread().getName() + "---" + (++num));

          try {
            this.wait(); // 每次打印一个数字，就让当前线程等待
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        } else {
          break;
    }
    }
 }

}
}

  <h3>生产者和消费者</h3>

public class Test {
public static void main(String[] args) {
Storehouse storehouse = new Storehouse();
Producer producer = new Producer(storehouse);
Consumer consumer = new Consumer(storehouse);
producer.start();
consumer.start();
}
}

/**
* 仓库
*/
class Storehouse {
private int total = 0; // 货物总数

/**
* 存储方法
*/
public synchronized void store() {
// 唤醒消费者 【可能消费者的线程的抢到的CPU时间片较多，其一旦消费了所有的产品，就会wait，所以需要用生产者来唤醒】
this.notify();

if (total < 20) {
  System.out.println("生产者生产了1个产品，当前库存：" + (++total));
} else {
  try {
    this.wait(); // 达到库存上线，停止生产
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
}

}

/**
* 取出方法
*/
public synchronized void getOut() {
// 唤醒生产者 【可能生产者的线程的抢到的CPU时间片较多，其一旦生产够了库存，就会wait，所以需要用消费者来唤醒】
this.notify();

if (total > 0) {
  System.out.println("消费者消费了1个产品，当前库存：" + (--total));
} else {
  try {
    this.wait(); // 没有库存，无法消费
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
}

}
}

/**
* 生产者
*/
class Producer extends Thread {
private Storehouse storehouse;

public Producer(Storehouse storehouse) {
this.storehouse = storehouse;
}

@Override
public void run() {
for (;;) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
storehouse.store();
}
}
}

/**
* 消费者
*/
class Consumer extends Thread {
private Storehouse storehouse;

public Consumer(Storehouse storehouse) {
this.storehouse = storehouse;
}

@Override
public void run() {
for (;;) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
storehouse.getOut();
}
}
}

线程同步的前提

⑴ 必须在同步的基础上（必须在同步代码块或同步方法中实现通信）。
⑵ 要求调用wait、notify、notifyAll的对象必须为锁对象。

线程的死锁问题

概念

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

示例【小华和小明同时过独木桥】

public class Test {
public static void main(String[] args) {
Person p1 = new Person(true); // 小明
Person p2 = new Person(false); // 小华
p1.start();
p2.start();
}
}

/**
* 小明
*/
class XiaoMing {
public void holdOn() {
System.out.println(“小明说：你先让我过去，我再让你过去”);
}

public void pass() {
System.out.println(“小明过了独木桥”);
}
}

/**
* 小华
*/
class XiaoHua {
public void holdOn() {
System.out.println(“小华说：你先让我过去，我再让你过去”);
}

public void pass() {
System.out.println(“小华过了独木桥”);
}
}

class Person extends Thread {
private static final XiaoMing xm = new XiaoMing();
private static final XiaoHua xh = new XiaoHua();
private boolean which; // true代表小明；false代表小华

public Person(boolean which) { // 传入boolean值，创建小明或小华
this.which = which;
}

@Override
public void run() {
if (which) { // 小明
synchronized (xm) {
xm.holdOn();
synchronized(xh) {
xm.pass();
}
}
} else { // 小华
synchronized (xh) {
xh.holdOn();
synchronized(xm) {
xh.pass();
}
}
}
}
}