多线程（复习）

多线程

进程、线程、程序的概念

线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

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

进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。

简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如 CPU 时间，内存空间，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。 线程是进程划分成的更小的运行单位。

线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。

并发与并行的理解

• 并行（Parallel）：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，我们称之为并行（Parallel）

其实决定并行的因素不是CPU的数量，而是CPU的核心数量，比如一个CPU多个核也可以并行。

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

CPU把一个时间段划分成几个时间片段（时间区间），然后在这几个时间区间之间来回切换，由于CPU处理的速度非常快，只要时间间隔处理得当，即可让用户感觉是多个应用程序同时在进行。

多线程的优点

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

什么时候使用多线程？

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

线程的创建与使用

Thread类

Java语言的JVM允许程序运行多个线程，它通过 java.lang.Thread类来体现。

Thread类的特性
每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

Thread类构造方法

Thread()：创建新的Thread对象
Thread(String threadname)：创建线程并指定线程实例名
Thread(Runnabletarget)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Thread(Runnable target, String name)：创建新的Thread对象

线程创建的俩种方式

第一种创建方式：

• 创建类继承 Thread
• 重写 Thread中的 run 方法
• 创建子类对象
• 调用 start() 方法

public class ThreadTest1 {
    @Test
    public void test() {
        MyThread t1 = new MyThread();
        // start方法的作用：1、启动线程 2、调用当前线程的 run 方法
        t1.start();

        // start() 方法每个线程只能调用一次
        MyThread t2 = new MyThread();
        t2.start();
        
    }
}

// 方式一
class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
             if ( i % 2 == 0) {
                 System.out.println(i);
             }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

第二种创建方式：

• 创建类实现 Runnable接口
• 实现 接口中的抽象方法 run
• 创建实现类对象
• 创建 Thread 对象，将实现类对象作为参数传进去
• 调用 Thread 中的 start() 方法

public class ThreadTest2 {
    public static void main(String[] args) {
        MyThread3 myThread3 = new MyThread3();
        Thread t1 = new Thread(myThread3);
        t1.start();
        // 在启动一个线程
        Thread t2 = new Thread(myThread3);
        t2.start();
    }
}

// 第二种方式
class MyThread3 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if ( i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() +" " + i);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

问题1：

start() 方法是调用当前线程中 的run方法，使用 Thread 对象调用 start ，不应该执行 Thread 类中的 run 方法吗？ 为什么执行的却是自定义类MyThread3中的方法？

确实执行了Thread 中的 run 方法，但是看 Thread 中 run 方法的源码：

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
1
2
3
4
5
6

这个 target 不等于 null 就会调用 target 中的run方法，而这个target 就是我们上面 new Thread 时传进去的 参数

线程相关的方法

* currentThread : 静态方法，返回执行的当前线程
* getName : 获取当前线程的名字
* setName : 设置当前线程的名字
* yield: 释放当前 cpu 的执行权
* join ： 在线程 a 中调用 线程 b的join方法， 此时线程 a进入阻塞状态，直到线程b执行完，线程 a才 结束阻塞状态
* stop ： 已过时，强制停止当前线程
* sleep ：让当前线程睡眠指定时间
* isAlive : 判断当前线程是否存活
1
2
3
4
5
6
7
8

代码演示：

public class ThreadMethodsTest1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread1 t1 = new MyThread1();
        t1.setName("t1");
        t1.start();
        // 设置主线程的优先级，优先级的高低只是增加了抢夺时间片的成功率。
        Thread.currentThread().setPriority(Thread.MAX_PRIORITY);

        for (int i = 0; i < 50; i++) {
            if (i % 2 !=0 ) {
                System.out.println(Thread.currentThread().getName()+ "  " + Thread.currentThread().getPriority()+  " " + i);
            }

            if (i == 21) {
                // 阻塞当前线程，等待 t1执行完，才会结束阻塞
                t1.join();
            }
        }
    }
}

class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
             if (i % 2 ==0 ) {
                 System.out.println(Thread.currentThread().getName() + " "+ i);
             }
            try {
                // 沉睡 1s
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (i % 10 == 0) {
                yield();

            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

买票问题：区分俩种创建线程的方式的区别

要求：

• 三个窗口共同卖票，总共 100 张
• 使用俩种方式实现，区别是什么

第一种方式：继承 Thread 创建多线程

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread4 t1 = new MyThread4();
        MyThread4 t2 = new MyThread4();
        MyThread4 t3 = new MyThread4();

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

    }
}

class MyThread4 extends Thread {
    private int ticket  = 100 ;
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(getName() + "卖了一张票: " + ticket);
                ticket-- ;
            }else {
                break;
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

问题一： 要求是三个窗口总共卖100张票，但是从输出结果看却是每个窗口都卖了100张票，这是为什么？

ticket 变量为实例变量，每一个实例都有一个 ticket 变量。因此 三个线程三个实例。

解决方法： 加上 static 变成 类变量。 private static int ticket = 100 ;

问题二： 虽然加上 static，但是卖第一张票时，却是三个线程同时卖的，这就是 线程安全问题。

第二种方式：实现Runnable接口

public class ThreadDemo1 {
    public static void main(String[] args) {
        MyThread5 myThread5 = new MyThread5();
        Thread t1 = new Thread(myThread5);
        Thread t2= new Thread(myThread5);
        Thread t3 = new Thread(myThread5);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

class MyThread5 implements Runnable {

    private int ticket  = 100 ;
    @Override
    public  void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "卖了一张票: " + ticket);
                ticket-- ;
            }else {
                break;
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

ticket 变量并没有加上 static，却共享了 100 张票。这是由于实现 Runnable 接口的方式，只需要创建一个 MyThread5 实例。 但是仍然会有线程安全问题

俩种创建线程方式的总结

优先使用 实现 Runnable接口的方式创建多线程

原因：

1. Java 只支持单继承，有局限性。而对于接口则可以实现多个
2. 实现的方式更适合处理数据共享的问题

线程的调度

• 调度策略
  • 时间片
    
  • 抢占式：高优先级的线程抢占CPU
• Java的调度方法
  • 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
  • 对高优先级，使用优先调度的抢占式策略

线程的优先级等级

MAX_PRIORITY：10

MIN _PRIORITY：1

NORM_PRIORITY：5 —>默认优先级

涉及的方法

• getPriority() ：返回线程优先值
• setPriority(intnewPriority) ：改变线程的优先级

说明:

• 高优先级的线程要抢占低优先级线程cpu的执行权。
• 但是只是从概率上讲，高优先级的线程高概率的情况下被执行。
• 并不意味着只有当高优先级的线程执行完以后，低优先级的线程才会被执行

线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

• 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
• 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
• 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态，run()方法定义了线程的操作和功能
• 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
• 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

线程同步

问题的提出

• 多个线程执行的不确定性引起执行结果的不稳定
• 多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

拿上面买票的例子出现的问题：

• 重票 和 错票 的问题 —— 出现了线程安全问题

出现的原因：

• 当某一个线程正在操作ticket的时候，尚未操作完成，另外一个线程又参与进来

解决方法：

• 当一个线程操作 ticket 时，不允许其他线程参与进来，等待当前线程执行完，其他线程才可以参与

Java 中使用同步机制，解决线程安全问题

方法一：同步代码

synchronized(同步监视器) {
	// 同步代码
}
1
2
3

• 同步代码：操作共享数据的代码

• 共享数据：多个线程共同操作的变量。比如：ticket就是共享数据

• 同步监视器：俗称：锁。任何一个类的对象，都可以来充当锁。

  • 多个线程必须共用同一把锁

优点：解决了线程同步安全问题

缺点：操作同步代码时，只能有一个线程执行，其他线程等待，相当于单线程的过程。

同步代码解决 实现 Runnable接口的线程安全问题：

public class ThreadSafetyTest {
    public static void main(String[] args) {
        MyThread6 myThread6 = new MyThread6();
        Thread t1 = new Thread(myThread6);
        Thread t2= new Thread(myThread6);
        Thread t3 = new Thread(myThread6);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

class  MyThread6 implements Runnable {

    private  int ticket  = 100 ;
    @Override
    public  void run() {
        while (true) {
            synchronized(this) {
                if (ticket > 0) {

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

                    System.out.println(Thread.currentThread().getName() + "卖了一张票: " + ticket);
                    ticket-- ;
                }else {
                    break;
                }
            }

        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

同步代码 解决 继承 Thread类的线程安全问题：

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread4 t1 = new MyThread4();
        MyThread4 t2 = new MyThread4();
        MyThread4 t3 = new MyThread4();

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

    }
}

 class  MyThread4 extends Thread {
    private static int ticket  = 100 ;
     // 锁
    private static Object obj = new Object();
    @Override
    public  void   run() {
        while (true) {
            synchronized(obj) {
                if (ticket > 0) {
                    System.out.println(getName() + "卖了一张票: " + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

方法二：同步方法

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

同步方法的同步监视器是 this，也就是方法所在类对象

同步方法解决 实现 Runnable 接口的 线程安全问题：

public class ThreadSafetyTest3 {
    public static void main(String[] args) {
        MyThread8 myThread8 = new MyThread8();
        Thread t1 = new Thread(myThread8);
        Thread t2= new Thread(myThread8);
        Thread t3 = new Thread(myThread8);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

class  MyThread8 implements Runnable {

    private  int ticket  = 100 ;
    @Override
    public  void run() {
        while (true) {
            show();
        }
    }
    // 同步方法
    public synchronized void show() {
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "卖了一张票: " + ticket);
            ticket-- ;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

不要再 run 方法中增加 synchronized ，否则就相当于单线程了，只有一个窗口卖票，是不符合要求的

同步方法解决 继承 Thread 类的线程安全问题：

public class ThreadSafetyTest4 {
        public static void main(String[] args) {
            thread.MyThread9 t1 = new thread.MyThread9();
            thread.MyThread9 t2 = new thread.MyThread9();
            thread.MyThread9 t3 = new thread.MyThread9();

            t1.setName("窗口一");
            t2.setName("窗口二");
            t3.setName("窗口三");

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

        }
    }

    class  MyThread9 extends Thread {
        private static int ticket  = 100 ;
        @Override
        public  void   run() {
            while (true) {
                show();
            }
        }
        // 将方法变成静态方法，保证该方法的唯一
        public static synchronized void show() {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "卖了一张票: " + ticket);
                ticket--;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

静态方法/静态变量都属于类的静态资源，为类的实例所共享

死锁问题

死锁的理解

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

说明

出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

我们使用同步时，要避免出现死锁。

死锁演示代码；

public class DeadLockTest {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

        //  线程 1
        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);
                    }
                }
            }
        }.start();

        // 线程2
        new Thread(() -> {
            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);
                }
            }
        }).start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

Lock锁解决线程安全问题

解决线程安全问题的方式三：lock锁 —》JDK5.0新增

注意

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

面试题：synchronized 与 Lock的异同？

相同：二者都可以解决线程安全问题

不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器，Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

优先使用顺序

Lock --> 同步代码块（已经进入了方法体，分配了相应资源）–> 同步方法（在方法体之外）

使用方法：

Lock配置 try- finally 代码块使用

 ReentrantLock lock = new ReentrantLock();
	try {
        lock.lock(); // 上锁
    }finally {
        lock.unlock(); // 释放锁
    }
1
2
3
4
5
6

代码演示：

public class LockTest {
        public static void main(String[] args) {
            MyThread10 myThread10 = new thread.MyThread10();
            Thread t1 = new Thread(myThread10);
            Thread t2= new Thread(myThread10);
            Thread t3 = new Thread(myThread10);

            t1.setName("窗口一");
            t2.setName("窗口二");
            t3.setName("窗口三");

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

    class MyThread10 implements Runnable {

        private int ticket  = 100 ;
        private ReentrantLock lock = new ReentrantLock();

        @Override
        public  void run() {
            while (true) {
                try {
                    // 上锁
                    lock.lock();

                    if (ticket > 0) {
                        System.out.println(Thread.currentThread().getName() + "卖了一张票: " + ticket);
                        ticket-- ;
                    }else {
                        break;
                    }
                } finally {
                    // 释放锁
                    lock.unlock();
                }
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

线程安全例题

要求：

* 银行有一个账户。
*  有两个储户分别向同一个账户存3000元，每次存1000，存3次。
*  每次存完打印账户余额。
1
2
3

• 多线程：俩个储户
• 共享对象：账户
• 存在线程安全问题
• 解决线程安全问题：同步代码、同步方法、Lock 锁

public class AccountTest {
    public static void main(String[] args) {
        User user = new User(new Account(0));
        Thread t1 = new Thread(user);
        Thread t2 = new Thread(user);

        t1.setName("用户1");
        t2.setName("用户2");

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

}
// 用户 —— 多线程
class User implements Runnable {

    private ReentrantLock lock = new ReentrantLock();
    // 共享的数据
    private Account account;

    public User(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (account.getBalance() < 3000) {
                    // 存钱1000
                    account.setBalance(account.getBalance()+1000);
                    account.showBalance();
                }else{
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}
class Account {
    // 账户余额
    private int balance ;

    public int getBalance() {
        return balance;
    }

    public Account(int balance) {
        this.balance = balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    // 打印余额
    public void showBalance() {
        System.out.println(Thread.currentThread().getName() + "存钱成功，" + "账户余额: " + getBalance());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

线程通信

示例： 要求俩个线程交替打印 1 ~ 100

代码：

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

        Thread t1 = new Thread(myThread11);
        Thread t2 = new Thread(myThread11);

        t1.setName("线程1");
        t2.setName("线程2");

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

class MyThread11 implements Runnable {

    private int number = 1;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (number <= 100) {
                    // 唤醒正在 wait() 的某一个线程
                    notify();
                    
                    System.out.println(Thread.currentThread().getName() + ": " + number);
                    number++;
                    try {
                        // 是当前线程进入阻塞状态，并释放锁
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

首先 线程 1 拿着锁执行到 if 语句，遇到 wait 方法会释放锁，并进行阻塞，这时锁被释放，线程 2 获取到锁，执行到 notify() 时 会唤醒 线程 1，此时线程 1 等待 线程2 释放锁。如此反复，交替执行。

关于线程通信的方法：

• wait() : 一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
• notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
• notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
• 这三个方法必须使用在 同步代码块 或者 同步方法中
• 这三个方法的调用者必须和同步监视器保持一致

面试题1 ： sleep() 和 wait() 有什么区别？

来源不同：sleep() 来自 Thread 类，wait() 来自 Object 类。

对于同步锁的影响不同：sleep() 不会影响同步锁的行为，如果当前线程持有同步锁，那么 sleep 是不会让线程释放同步锁的。wait() 会释放同步锁，让其他线程进入 synchronized 代码块执行。

使用范围不同：sleep() 可以在任何地方使用。wait() 只能在同步控制方法或者同步控制块里面使用，否则会抛 IllegalMonitorStateException。

恢复方式不同：两者会暂停当前线程，但是在恢复上不太一样。sleep() 在时间到了之后会重新恢复；wait() 则需要其他线程调用同一对象的 notify()/nofityAll() 才能重新恢复。

经典例题：生产者、消费者

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

分析：

1.是否是多线程的问题？是，生产者的线程，消费者的线程

2.是否有共享数据的问题？是，店员、产品、产品数

3.如何解决线程的安全问题？同步机制，有三种方法

4.是否涉及线程的通信？是

代码：

public class ProducerTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer producer = new Producer(clerk);
        Thread t1 = new Thread(producer);
        Consumer consumer = new Consumer(clerk);
        Thread t2 = new Thread(consumer);

        t1.setName("生产者");
        t1.start();
        t2.setName("消费者");
        t2.start();

    }

}

// 店员
class Clerk {

    private int products = 0;

    // 生产产品
    public synchronized void producerProducts()  {
        if (products < 20) {
            products++;
            System.out.println(Thread.currentThread().getName() + "生产的第" + products + "个产品");
            // 生产一个就可以唤醒消费线程
            notify();
        } else {
            try {
                //  生产超过20 就等一会
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 消费产品
    public synchronized void consumerProducts() {
        if (products > 0) {
            System.out.println(Thread.currentThread().getName() + "消费的第" + products + "个产品");
            products--;
            // 消费一个唤醒生产线程
            notify();
        } else {
            try {
                //    产品没有了 就等一会
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 生产者
class Producer implements Runnable {

    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println("生产者开始生产产品: -------");
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.producerProducts();
        }
    }
}

// 消费者
class Consumer implements Runnable {
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println("消费者开始消费产品: -------");
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumerProducts();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

JDK5 新增的创建线程的方式

新增方式一： 实现 Callable 接口

• 创建类实现 Callable 接口
• 重写 call 方法
• 创建实现类对象
• 创建 FutureTask 对象，并将实现类对象传进去
• 创建 Thread 对象，并将 FutureTask 对象传进去

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread12 myThread12 = new MyThread12();
        FutureTask<Integer> futureTask = new FutureTask<>(myThread12);
        // 启动线程
        new Thread(futureTask).start();

        // 获取返回值
        Integer sum = futureTask.get();
        System.out.println(sum);
    }
}

class MyThread12 implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100 ; i++) {
            System.out.println(i);
            sum += i;
        }
        return sum;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Futrue 接口

• 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
• FutrueTask 是 Futrue 接口的唯一的实现类
• FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

实现 Callable接口 与 实现 Runnable 接口的异同？

相同点：都是创建线程的一种方式

不同点：

• call() 有返回值，并且能够抛异常，被外面操作捕获到，获取异常信息，Callable 支持泛型

新增方式二： 使用线程池

1、背景：

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

2、思路：

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

3、好处：

• 提高响应速度（减少了创建新线程的时间）
• 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
• 便于线程管理
  • corePoolSize：核心池的大小
  • maximumPoolSize：最大线程数
  • keepAliveTime：线程没有任务时最多保持多长时间后会终止
  • …

线程池相关 API

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

• ExecutorService：真正的线程池接口。常见子类 ThreadPoolExecutor

• void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable

• Future submit(Callable task)：执行任务，有返回值，一般用来执行Callable

• void shutdown()：关闭连接池

• Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

• Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池

• Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池

• Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池

• Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

代码演示：

public class ThreadLocalTest {
    public static void main(String[] args) {
        // 创建指定容量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        // execute 一般用来执行 Runnable 接口
        service.execute(new MyThread13());
        // submit 一般用来执行 Callable 接口
        service.submit(new MyThread14());
        // 管理线程池
        ThreadPoolExecutor pool = (ThreadPoolExecutor) service;
        // 最大线程数
        pool.setMaximumPoolSize(10);
        // 核心池大小
        pool.setCorePoolSize(10);
        


    }
}

class MyThread13 implements  Runnable{

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

class MyThread14 implements Callable {

    @Override
    public Object call() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 != 0) {
                System.out.println(i);
            }
        }
        return null ;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

xecutors.newSingleThreadExecutor()：创建一个只有一个线程的线程池

• Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

代码演示：

public class ThreadLocalTest {
    public static void main(String[] args) {
        // 创建指定容量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        // execute 一般用来执行 Runnable 接口
        service.execute(new MyThread13());
        // submit 一般用来执行 Callable 接口
        service.submit(new MyThread14());
        // 管理线程池
        ThreadPoolExecutor pool = (ThreadPoolExecutor) service;
        // 最大线程数
        pool.setMaximumPoolSize(10);
        // 核心池大小
        pool.setCorePoolSize(10);
        


    }
}

class MyThread13 implements  Runnable{

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

class MyThread14 implements Callable {

    @Override
    public Object call() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 != 0) {
                System.out.println(i);
            }
        }
        return null ;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44