Java 多线程

1 多线程

1.1 多线程介绍

  学习多线程之前，我们先要了解几个关于多线程有关的概念。
  进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

  线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
  简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

  什么是多线程呢？即就是一个程序中有多个线程在同时执行。
  单线程程序：即，若有多个任务只能依次执行。当上一个任务执行结束后，下一个任务开始执行。如，去网吧上网，网吧只能让一个人上网，当这个人下机后，下一个人才能上网。
  多线程程序：即，若有多个任务可以同时执行。如，去网吧上网，网吧能够让多个人同时上网。

1.2 程序运行原理

分时调度
  所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度
  优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

1.2.1 抢占式调度详解

  大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。

  实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。
  其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

1.3 主线程

  回想我们以前学习中写过的代码，当我们在dos命令行中输入java空格类名回车后，启动JVM，并且加载对应的class文件。虚拟机并会从main方法开始执行我们的程序代码，一直把main方法的代码执行结束。如果在执行过程遇到循环时间比较长的代码，那么在循环之后的其他代码是不会被马上执行的。
  代码演示如下：

package com.qtw.api;

public class TestDemo{
    public static void main(String[] args) {
        System.out.println("start");
        show();
        System.out.println("end");
    }

    public static void show(){
        int sum = 0;
        for(int i = 0; i <= 100; i++){
            sum = sum + i;
            System.out.println("sum = "+ sum);
        }
    }
}

  若在上述代码中show方法中的循环执行次数很多，这时在show();下面的代码是不会马上执行的，并且在dos窗口会看到不停的输出sum=值，这样的语句。为什么会这样呢？
  原因是：jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程。当程序的主线程执行时，如果遇到了循环而导致程序在指定位置停留时间过长，则无法马上执行下面的程序，需要等待循环结束后能够执行。
  那么，能否实现一个主线程负责执行其中一个循环，再由另一个线程负责其他代码的执行，最终实现多部分代码同时执行的效果？
  能够实现同时执行，通过Java中的多线程技术来解决该问题。

1.4 Thread类

  该如何创建线程呢？通过API中搜索，查到Thread类。通过阅读Thread类中的描述。Thread是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

  构造方法

  常用方法

  继续阅读，发现创建新执行线程有两种方法。
  一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象，开启线程。run方法相当于其他线程的main方法。
  另一种方法是声明一个实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。

1.5 创建线程方式一继承Thread类

创建线程的步骤：
  1. 定义一个类继承Thread。
  2. 重写run方法。
  3. 创建子类对象，就是创建线程对象。
  4. 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。
自定义线程类MyThread .java

package com.qtw.api;

public class MyThread extends Thread {
    //定义指定线程名称的构造方法
    public MyThread(String name) {
        //调用父类的String参数的构造方法，指定线程的名称
        super(name);
    }
    /**
     * 重写run方法，完成该线程执行的逻辑
     */
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"：正在执行！"+i);
        }
    }
}

测试类TestDemo.java

package com.qtw.api;

public class TestDemo{
    public static void main(String[] args) {
        //创建自定义线程对象
        MyThread mt1 = new MyThread("新的线程1");
        MyThread mt2 = new MyThread("新的线程2");
        //开启新线程
        mt1.start();
        mt2.start();
        //在主方法中执行for循环
        for (int i = 0; i < 100; i++) {
            System.out.println("main线程！"+i);
        }
    }
}

  思考：线程对象调用 run方法和调用start方法区别？
  线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。

1.5.1 继承Thread类原理

  我们为什么要继承Thread类，并调用其的start方法才能开启线程呢？
  继承Thread类：因为Thread类用来描述线程，具备线程应该有功能。那为什么不直接创建Thread类的对象呢？如下代码：

Thread t1 = new Thread();
t1.start();
//这样做没有错，但是该start调用的是Thread类中的run方法，
//而这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代码。

  创建线程的目的是什么？
  是为了建立程序单独的执行路径，让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。
  对于之前所讲的主线程，它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。
  Thread类run方法中的任务并不是我们所需要的，只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置（run方法），那么只要在编写位置（run方法）中定义任务代码即可。所以进行了重写run方法动作。

1.5.2 多线程的内存图解

  多线程执行时，到底在内存中是如何运行的呢？以上个程序为例，进行图解说明，多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。

  当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

1.5.3 获取线程名称

  开启的线程都会有自己的独立运行栈内存，那么这些运行的线程的名字是什么呢？该如何获取呢？既然是线程的名字，按照面向对象的特点，是哪个对象的属性和谁的功能，那么我们就去找那个对象就可以了。查阅Thread类的API文档发现有个方法是获取当前正在运行的线程对象。还有个方法是获取当前线程对象的名称。既然找到了，我们就可以试试。

  Thread.currentThread()获取当前线程对象
  Thread.currentThread().getName();获取当前线程对象的名称
自定义线程类MyThread.java

package com.qtw.api;

public class MyThread extends Thread {
    /**
     * 重写run方法，完成该线程执行的逻辑
     */
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+",i="+i);
        }
    }
}

测试类TestDemo.java

package com.qtw.api;

public class TestDemo{
    public static void main(String[] args) {
        //创建两个线程任务
        MyThread d1 = new MyThread();
        MyThread d2 = new MyThread();
        d1.start();//开启一个新线程，新线程调用run方法
        d2.start();//开启一个新线程，新线程调用run方法
    }
}

  通过结果观察，原来主线程的名称：main；自定义的线程：Thread-0，线程多个时，数字顺延。如Thread-1......
  进行多线程编程时，不要忘记了Java程序运行是从主线程开始，main方法就是主线程的线程执行内容。

1.6 创建线程方式—实现Runnable接口

  创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。
  为何要实现Runnable接口，Runable是啥玩意呢？继续API搜索。
  查看Runnable接口说明文档：Runnable接口用来指定每个线程要执行的任务。包含了一个 run 的无参数抽象方法，需要由接口实现类重写该方法。

接口中的方法

Thread类构造方法

创建线程的步骤。
  1. 定义类实现Runnable接口。
  2. 覆盖接口中的run方法。。
  3. 创建Thread类的对象
  4. 将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
  5. 调用Thread类的start方法开启线程。
自定义线程执行任务类MyRunnable.java

package com.qtw.api;

public class MyRunnable implements Runnable{
    //实现run方法，同时定义线程要执行的run方法逻辑
    public void run(){
        for(int i = 1; i <= 100; i++){
            System.out.println(Thread.currentThread().getName()+"："+i);
        }
    }
}

测试类TestDemo.java

package com.qtw.api;

public class TestDemo{
    public static void main(String[] args) {
        //创建线程执行目标类对象
        Runnable runn1 = new MyRunnable();
        Runnable runn2 = new MyRunnable();
        //将Runnable接口的子类对象作为参数传递给Thread类的构造函数
        Thread thread1 = new Thread(runn1);
        Thread thread2 = new Thread(runn2);
        //开启线程
        thread1.start();
        thread2.start();

    }
}

1.6.1 实现Runnable的原理

  为什么需要定一个类去实现Runnable接口呢？继承Thread类和实现Runnable接口有啥区别呢？
  实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。
  创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。

1.6.2 实现Runnable的好处

  第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

1.7 线程的匿名内部类使用

  使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
  1. 创建线程对象时，直接重写Thread类中的run方法

package com.qtw.api;

public class TestDemo{
    public static void main(String[] args) {
        new Thread() {
            public void run() {
                for (int x = 0; x < 40; x++) {
                    System.out.println(Thread.currentThread().getName()
                            + "...X...." + x);
                }
            }
        }.start();
    }
}

  2. 使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法

package com.qtw.api;

public class TestDemo{
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            public void run() {
                for (int x = 0; x < 40; x++) {
                    System.out.println(Thread.currentThread().getName()
                            + "...Y...." + x);
                }
            }
        };
        new Thread(r).start();
    }
}

2 线程池

  线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

  我们详细的解释一下为什么要使用线程池？
  在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。
  线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。

2.2 使用线程池方式--Runnable接口

  通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。
  Executors：线程池创建工厂类

public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象

  ExecutorService：线程池类

Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行

  Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

使用线程池中线程对象的步骤：
  1. 创建线程池对象
  2. 创建Runnable接口子类对象
  3. 提交Runnable接口子类对象
  4. 关闭线程池
Runnable接口实现类

package com.qtw.api;

public class MyRunnable implements Runnable{
    //实现run方法，同时定义线程要执行的run方法逻辑
    public void run(){
        for(int i = 1; i <= 10; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"："+i);
        }
    }
}

代码演示：

package com.qtw.api;

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class TestDemo{
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
        //创建Runnable实例对象
        MyRunnable r = new MyRunnable();

        //自己创建线程对象的方式
        //Thread t = new Thread(r);
        //t.start();// ---> 调用MyRunnable中的run()
        //从线程池中获取线程对象,然后调用MyRunnable中的run()
        service.submit(r);
        //再获取个线程对象，调用MyRunnable中的run()
        service.submit(r);
        service.submit(r);
        service.submit(r);
        //注意：submit方法调用结束后，程序并不终止，
        //是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中

        //关闭线程池,一般不进行次操作
        //service.shutdown();
    }
}

2.3 使用线程池方式—Callable接口

  Callable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。
ExecutorService：线程池类

<T> Future<T> submit(Callable<T> task)
//获取线程池中的某一个线程对象，并执行线程中的call()方法

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
使用线程池中线程对象的步骤：
  1. 创建线程池对象
  2. 创建Callable接口子类对象
  3. 提交Callable接口子类对象
  4. 关闭线程池
演示代码

package com.qtw.api;

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class TestDemo{
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
        //创建Callable对象
        MyCallable c = new MyCallable();

        //从线程池中获取线程对象,然后调用MyRunnable中的run()
        service.submit(c);

        //再获取个教练
        service.submit(c);
        service.submit(c);
        //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
        // 将使用完的线程又归还到了线程池中
        //关闭线程池
        //service.shutdown();



    }
}

Callable接口实现类,call方法可抛出异常、返回线程任务执行完毕后的结果

package com.qtw.api;

import java.util.concurrent.Callable;

public class MyCallable implements Callable {
    //call的返回值类型是泛型，call()抛父类异常
    public Object call() throws Exception{
        for (int i = 1; i <= 10; i++) {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + "：" + i);
        }
        return null;
    }
}

2.4 线程池练习：返回两个数相加的结果

要求：通过线程池中的线程对象，使用Callable接口完成两个数求和操作
Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
V get() 获取Future对象中封装的数据结果
代码演示：

package com.qtw.api;

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

public class TestDemo{
    public static void main(String[] args) throws Exception{
        //创建线程池对象
        ExecutorService threadPool = Executors.newFixedThreadPool(2);

        //创建一个Callable接口子类对象
        //MyCallable c = new MyCallable();
        MyCallable c = new MyCallable(100, 200);
        MyCallable c2 = new MyCallable(10, 20);

        //获取线程池中的线程，调用Callable接口子类对象中的call()方法, 完成求和操作
        //<Integer> Future<Integer> submit(Callable<Integer> task)
        // Future 结果对象
        Future<Integer> result = threadPool.submit(c);
        //此 Future 的 get 方法所返回的结果类型
        Integer sum = result.get();
        System.out.println("sum=" + sum);

        //再演示
        result = threadPool.submit(c2);
        sum = result.get();
        System.out.println("sum=" + sum);
        //关闭线程池(可以不关闭)



    }
}

Callable接口实现类

package com.qtw.api;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    //成员变量
    private int x = 5;
    private int y = 3;
    //构造方法
    public MyCallable(){
    }
    public MyCallable(int x, int y){
        this.x = x;
        this.y = y;
    }

    public Integer call() throws Exception {
        return x+y;
    }
}

3 多线程安全

3.1 线程安全

  如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
  我们通过一个案例，演示线程的安全问题：
  电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “功夫熊猫3”，本次电影的座位共100个(本场电影只能卖100张票)。
  我们来模拟电影院的售票窗口，实现多个窗口同时卖 “功夫熊猫3”这场电影票(多个窗口一起卖这100张票)需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟
测试类

package com.qtw.api;

public class TestDemo{
    public static void main(String[] args) {
        //创建票对象
        Ticket ticket = new Ticket();

        //创建3个窗口
        Thread t1  = new Thread(ticket, "窗口1");
        Thread t2  = new Thread(ticket, "窗口2");
        Thread t3  = new Thread(ticket, "窗口3");

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

模拟票

package com.qtw.api;

public class Ticket implements Runnable {
    //共100票
    private int ticket = 100;

    public void run() {
        //模拟卖票
        while (true) {
            if (ticket > 0) {
                //模拟选坐的操作
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
            }
        }
    }
}

运行结果发现：上面程序出现了问题
  票出现了重复的票
  错误的票 0、-1

  其实，线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

3.2 线程同步（线程安全处理Synchronized）

java中提供了线程同步机制，它能够解决上述的线程安全问题。线程同步的方式有两种：
  方式1：同步代码块
  方式2：同步方法

3.2.1 同步代码块

同步代码块: 在代码块声明上 加上synchronized

synchronized (锁对象) {
    可能会产生线程安全问题的代码
}

  同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。
  使用同步代码块，对电影院卖票案例中Ticket类进行如下代码修改：

package com.qtw.api;

public class Ticket implements Runnable {
    //共100票
    private int ticket = 100;
    Object lock = new Object();

    public void run() {
        //模拟卖票
        while (true) {
            synchronized (lock){
                if (ticket > 0) {
                    //模拟选坐的操作
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
                }
            }
        }
    }
}

当使用了同步代码块后，上述的线程的安全问题，解决了。

3.2.2 同步方法

同步方法：在方法声明上加上synchronized

public synchronized void method(){
    可能会产生线程安全问题的代码
}

同步方法中的锁对象是 this

使用同步方法，对电影院卖票案例中Ticket类进行如下代码修改：

package com.qtw.api;

public class Ticket implements Runnable {
    //共100票
    private int ticket = 100;

    public void run() {
        //模拟卖票
        while (true) {
            if (ticket > 0) {
                //模拟选坐的操作
                method();
            }
        }

    }

    //同步方法,锁对象this
    public synchronized void method(){
        if (ticket > 0) {
            //模拟选坐的操作
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
        }
    }
}

静态同步方法: 在方法声明上加上static synchronized

public static synchronized void method(){
可能会产生线程安全问题的代码
}

静态同步方法中的锁对象是 类名.class

3.3 死锁

  同步锁使用的弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：程序出现无限等待，这种现象我们称为死锁。这种情况能避免就避免掉。

3.4 Lock接口

  查阅API，查阅Lock接口描述，Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。推荐使用
  Lock接口中的常用方法

  Lock提供了一个更加面对对象的锁，在该锁中提供了更多的操作锁的功能。
  我们使用Lock接口，以及其中的lock()方法和unlock()方法替代同步，对电影院卖票案例中Ticket类进行如下代码修改：

package com.qtw.api;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Ticket implements Runnable {
    //共100票
    int ticket = 100;

    //创建Lock锁对象
    Lock ck = new ReentrantLock();

    public void run() {
        //模拟卖票
        while(true){
            //synchronized (lock){
            ck.lock();
            if (ticket > 0) {
                //模拟选坐的操作
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
            }
            ck.unlock();
            //}
        }
    }
}

3.5 等待唤醒机制

  在开始讲解等待唤醒机制之前，有必要搞清一个概念——线程之间的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。
等待唤醒机制所涉及到的方法：
  wait（）:等待，将正在执行的线程释放其执行资格 和 执行权，并存储到线程池中。
  notify（）：唤醒，唤醒线程池中被wait（）的线程，一次唤醒一个，而且是任意的。
  notifyAll（）： 唤醒全部：可以将线程池中的所有wait() 线程都唤醒。
  其实，所谓唤醒的意思就是让 线程池中的线程具备执行资格。必须注意的是，这些方法都是在 同步中才有效。同时这些方法在使用时必须标明所属锁，这样才可以明确出这些方法操作的到底是哪个锁上的线程。
  仔细查看JavaAPI之后，发现这些方法 并不定义在 Thread中，也没定义在Runnable接口中，却被定义在了Object类中，为什么这些操作线程的方法定义在Object类中？
  因为这些方法在使用时，必须要标明所属的锁，而锁又可以是任意对象。能被任意对象调用的方法一定定义在Object类中。

接下里，我们先从一个简单的示例入手:

如上图说示，输入线程向Resource中输入name ,sex , 输出线程从资源中输出，先要完成的任务是：
1.当input发现Resource中没有数据时，开始输入，输入完成后，叫output来输出。如果发现有数据，就wait();
2.当output发现Resource中没有数据时，就wait() ；当发现有数据时，就输出，然后，叫醒input来输入数据。

下面代码，模拟等待唤醒机制的实现：
模拟资源类

package com.qtw.api;

public class Resource {
    private String name;
    private String sex;
    private boolean flag = false;

    public synchronized void set(String name, String sex) {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 设置成员变量
        this.name = name;
        this.sex = sex;
        // 设置之后，Resource中有值，将标记该为 true ,
        flag = true;
        // 唤醒output
        this.notify();
    }

    public synchronized void out() {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 输出线程将数据输出
        System.out.println("姓名: " + name + "，性别: " + sex);
        // 改变标记，以便输入线程输入数据
        flag = false;
        // 唤醒input，进行数据输入
        this.notify();
    }
}

输入线程任务类

package com.qtw.api;

public class Input implements Runnable {
    private Resource r;

    public Input(Resource r) {
        this.r = r;
    }

    public void run() {
        int count = 0;
        while (true) {
            if (count == 0) {
                r.set("小明", "M");
            } else {
                r.set("小花", "F");
            }
            // 在两个数据之间进行切换
            count = (count + 1) % 2;
        }
    }
}

输出线程任务类

package com.qtw.api;

public class Output implements Runnable {
    private Resource r;

    public Output(Resource r) {
        this.r = r;
    }

    public void run() {
        while (true) {
            r.out();
        }
    }
}

测试类

package com.qtw.api;

public class TestDemo {
    public static void main(String[] args) {
        // 资源对象
        Resource r = new Resource();
        // 任务对象
        Input in = new Input(r);
        Output out = new Output(r);
        // 线程对象
        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        // 开启线程
        t1.start();
        t2.start();
    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 216,470评论 6赞 501
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,393评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 162,577评论 0赞 353
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,176评论 1赞 292
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,189评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,155评论 1赞 299
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,041评论 3赞 418
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,903评论 0赞 274
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,319评论 1赞 310
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,539评论 2赞 332
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,703评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,417评论 5赞 343
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,013评论 3赞 325
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,664评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,818评论 1赞 269
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,711评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,601评论 2赞 353