第八章 多线程

第八章——多线程

image-20210408203242596

8.1 基本概念：程序，进程，线程

image-20210408203344460image-20210408203410908

image-20210408203426187

image-20210408203441756

image-20210408203548452

image-20210408203604827

8.2 线程的创建和使用

image-20210408203638764

image-20210408203653012

image-20210408203713142

image-20210408203727091

image-20210408203744078

package com.brook.java;
/**
 * 多线程的创建，方式一:继承于Thread类
 * 1.创建一个继承于Thread类的子类
 * 2.重写Thread类的run() -->将此线程执行的操作声明在run()中
 * 3. 创建Thread类的子类的对象
 * 4、通过此对象调用start()方法
 *
 * @author brook
 * @create 2021-04-08 22:01
 */

 // 1.创建一个继承于Thread类的子类
class MyThread extends Thread{
    // 重写Thread类的run()
    @Override
    public void run(){
        for (int i = 0; i < 100; i++){
            System.out.println("子线程：" + i + "############");
        }
    }
}

public class TestThread {
    public static void main(String[] args) {
        // 3. 创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        // 4. 启动线程，并调用当前线程的run()方法
        t1.start();
        // t1.run() ，run()方法为普通方法，没有启动多线程
        
		//说明:当main线程启动一个子线程Thread-0，主线程不会阻塞，会继续执行
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程：" + i + "$$$$$$$$$$$$$$");
        }
    }
}

image-20210408203800796

image-20210408203815564

image-20210408203830169

package com.brook.thread;

/**
 * 创建多线程的方式二:实现Runnable接口
 * 1. 创建一个实现Runnable接口的子类；
 * 2．重写Runnable接口中的run方法；
 * 3. 通过Thread类含参构造器创建线程对象；
 * 4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中
 * 5. 调用Thread类的start方法；
 *
 * 例子:遍历100以内的所有的偶数
 *
 * @author brook
 * @create 2021-04-09 10:00
 */
public class TestThread1 {
    public static void main(String[] args) {
        // 3. 创建实现类的对象
        MyThread1 mythread1 = new MyThread1();
        // 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mythread1);
        // 5. 通过Thread类的对象调用start(): ①启动线程  ②调用当前线程的run()-->调用了runnable类型的target.run()方法
        t1.setName("线程一：");
        t1.start();

        Thread t2 = new Thread(mythread1);
        t2.setName("线程二：");
        t2.start();

    }
}

// 1.创建一个实现了Runnable接口的类
class MyThread1 implements Runnable{
    // 2. 实现类去实现Runnable中的抽象方法: run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0)
                System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

image-20210408203849197

image-20210408203902940

package com.brook.exer;

/**
 *                                       练习
 * 创建两个分线程，让其中一个线程输出1-100之间的偶数，另一个线程输出1-100之间的奇数。
 * @author brook
 * @create 2021-04-08 22:37
 */
public class ThreadDemo {
    public static void main(String[] args) {
//        MyThread1 t1 = new MyThread1();
//        MyThread2 t2 = new MyThread2();
//        t1.start();
//        t2.start();

        // 创建Thread类的匿名子类的方式
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if(i % 2 == 0)
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }.start();

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

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

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

image-20210408203921325

image-20210408203934079

image-20210408203949412

image-20210408204003574

package com.brook.thread;

/**
 * 线程的优先级: 优先级高的线程被执行的概率更大，但不绝对
 * 1.
 *  MAX_PRIORITY: 10
 *  MIN _PRIORITY: 1
 *  NORM_PRIORITY: 5 -->默认优先级
 * 2.如何获取和设置当前线程的优先级:
 *  getpriority():获取线程的优先级
 *  setPriority(int p)∶设置线程的优先级
 *
 * @author brook
 * @create 2021-04-09 0:22
 */
public class ThreadMethodTest {
    public static void main(String[] args) {
        //给分线程命名
        HelloThread h1 = new HelloThread("子线程");
        // 设置分线程的优先级
        h1.setPriority(Thread.MAX_PRIORITY);
        h1.start();
        //给主线程命名
        Thread.currentThread().setName("主线程");
        // 设置主线程的优先级
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for (int i = 0; i < 100; i++) {
            if(i % 2 != 0)
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
        }
    }
}

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

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

例题：多窗口卖票

方式一

package com.brook.thread;

/**
 * 例子:创建三个窗口卖票，总票数为100张
 * 存在线程安全问题，待解决
 * @author brook
 * @create 2021-04-09 0:52
 */
public class WindowTest {
    public static void main(String[] args) {
        Window w1 = new Window("窗口一");
        Window w2 = new Window("窗口二");
        Window w3 = new Window("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }
}

class Window extends Thread{
    private static int ticket = 100;

    public Window(String name) {
        super(name);
    }

    @Override
    public void run() {
        while (true){
            if (ticket > 0){
                System.out.println(getName() + "：卖票，票号为：" + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}

方式二

package com.brook.thread;

/**
 * 例子:创建三个窗口卖票，总票数为100张: 方法二
 * @author brook
 * @create 2021-04-09 10:59
 */
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("NO. 1: ");
        t2.setName("NO. 2: ");
        t3.setName("NO. 3: ");

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

class Window1 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;
            }
        }
    }
}

比较创建线程的两种方式

开发中:优先选择实现Runnable接口的方式原因:

1．实现的方式没有类的单继承性的局限性
2．实现的方式更适合来处理多个线程有共享数据的情况。

联系: public class Thread implements Runnable
相同点: 两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

image-20210408204019981

复习题

1. 谈谈你对程序、进程、线程的理解

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

进程：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。——生命周期

  • 如:运行中的QQ，运行中的MP3播放器
  • 程序是静态的，进程是动态的
  • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。

  • 若一个进程同一时间并行执行多个线程，就是支持多线程的
  • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
  • 一个进程中的多个线程共享相同的内存单元/内存地址空间→它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

2. 代码完成继承Thread的方式创建分线程，并遍历100以内的自然数。

public class TestThread{
    public static void main(String[] args){
 		MyThread t = new MyThread("线程一");
        t.start();
        Thread.setName("线程二");
        for (int i = 0; i < 100; i++)
        	System.out.println(Thread.currentThread.getName() + " : " + i);
    }
}


class MyThread extends Thread{
    public MyThread(String name){
        super(name);
    }
    
    @Override
    public void run(){
        for (int i = 0; i < 100; i++)
            System.out.println(getName() + " : " + i);
    }
}

3. 代码完成实现Runnable 接口的方法创建分线程，并遍历100以内的自然数

public class TestThread{
    public static void main(String[] args){
 		MyThread1 mythread1 = new MyThread();
        Thread t1 = new Thread(mythread1);
        Thread t2 = new Thread(mythread1);
        t1.setName("线程一")
        t2.setName("线程二")
        t1.start();
        t2.start();
    }
}


class MyThread1 implements Runnable{

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

4. 对比两种创建方式

开发中:优先选择实现Runnable接口的方式原因:

1．实现的方式没有类的单继承性的局限性
2．实现的方式更适合来处理多个线程有共享数据的情况。

联系: public class Thread implements Runnable
相同点: 两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。

5. 说说你对IDEA中 Project和 Module的理解

IDEA中的project为最顶级的目录，下面包含众多module，project类似于eclipse中的workspace，而module相当于eclipse中的project；

8.3 线程的生命周期

image-20210409203130396

image-20210409203151138

image-20210409203209769

8.4 线程的同步

image-20210409225542328

image-20210409225602886

image-20210409225643358

/** * 1.问题:卖票过程中，出现了重票、错票-->出现了线程的安全问题 * 2.问题出现的原因:当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票 * 3.如何解决:当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时 *          线程才可以开始操作ticket。这种情况即使线程α出现了阻塞，也不能被改变。 *           * @author brook * @create 2021-04-09 23:05 */public class TicketDemo {    public static void main(String[] args) {        Ticket t = new Ticket();        Thread t1 = new Thread(t);        Thread t2 = new Thread(t);        Thread t3 = new Thread(t);        t1.setName("window t1");        t2.setName("window t2");        t3.setName("window t3");        t1.start();        t2.start();        t3.start();    }}class Ticket implements  Runnable{    private int ticket = 100;    @Override    public void run() {        while (true){            if (ticket > 0){                try {                    Thread.sleep(100);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println(Thread.currentThread().getName() + " ticket NO.: " + ticket--);            }else                break;        }    }}

image-20210409225700333

image-20210409225721844

image-20210409225843274

image-20210409235141977

使用同步代码块解决卖票中的线程安全问题

1. 实现Runnable接口的方法

/** * 方式一: 同步代码块 * * synchronized(同步监视器){ *      //需要被同步的代码 * } * * 说明: 1.操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少了。 *      2.共享数据:多个线程共同操作的变量。比如: ticket就是共享数据。 *      3.同步监视器，俗称：锁。  任何一个类的对象，都可以充当锁。 *          要求:多个线程必须要共用同一把锁。 *  补充:在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。 * * * * @author brook * @create 2021-04-09 23:05 */public class TicketDemo {    public static void main(String[] args) {        Ticket t = new Ticket();        Thread t1 = new Thread(t);        Thread t2 = new Thread(t);        Thread t3 = new Thread(t);        t1.setName("window t1");        t2.setName("window t2");        t3.setName("window t3");        t1.start();        t2.start();        t3.start();    }}class Ticket implements  Runnable {    private int ticket = 100;    Object obj = new Object();    @Override    public void run() {        while (true) {            synchronized (obj) { // 此处可以用this,synchronized(this),this代表当前对象                if (ticket > 0) {                    try {                        Thread.sleep(100);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    System.out.println(Thread.currentThread().getName() + " ticket NO.: " + ticket--);                } else                    break;            }        }    }}

2. 继承Thread类的方式

/** * 例子: 创建三个窗口卖票，总票数为100张.使用继承Thread类的方式 * * 使用同步代码块解决继承Thread类的方式的线程安全问题 * * 补充: 在继承Thread类创建多线程的方式中，慎用this充当同步监视器。考虑使用当前类充当同步监视器 * * @author brook * @create 2021-04-10 10:28 */public class TicketDemo1 {    public static void main(String[] args) {        Ticket1 t1 = new Ticket1();        Ticket1 t2 = new Ticket1();        Ticket1 t3 = new Ticket1();        t1.setName("window 1");        t2.setName("window 2");        t3.setName("window 3");        t1.start();        t2.start();        t3.start();    }}class Ticket1 extends Thread {    private static int ticket = 100;    private static Object obj = new Object(); // 锁    @Override    public void run() {        while (true) {            // synchronized (Ticket1.class)            synchronized (obj) { // 线程同步， 此处不能用this，因为对象不唯一                if (ticket > 0) {                    try {                        Thread.sleep(100);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    System.out.println(Thread.currentThread().getName() + " ticket NO.: " + ticket--);                }else                    break;            }        }    }}

使用同步方法解决卖票中的线程安全问题

1. 实现Runnable接口的方法

/** * * 使用同步方法解决实现Runnable接口的线程安全问题 * * @author brook * @create 2021-04-10 11:06 */public class TicketDemo2 {    public static void main(String[] args) {        Ticket2 t = new Ticket2();        Thread t1 = new Thread(t);        Thread t2 = new Thread(t);        Thread t3 = new Thread(t);        t1.setName("window t1");        t2.setName("window t2");        t3.setName("window t3");        t1.start();        t2.start();        t3.start();    }}class Ticket2 implements  Runnable {    private int ticket = 100;    // 同步方法    private synchronized void show() {        if (ticket > 0) {            try {                Thread.sleep(100);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println(Thread.currentThread().getName() + " ticket NO.: " + ticket--);        }    }    @Override    public  void run() { // 同步监视器this        while (true) {            show();            if (ticket <= 0)                break;        }    }}

2. 继承Thread类

/** * * 例子: 创建三个窗口卖票，总票数为100张.使用继承Thread类的方式 * *  使用同步方法解决继承Thread类的线程安全问题 * * * @author brook * @create 2021-04-10 12:04 */public class TicketDemo3 {    public static void main(String[] args) {        Ticket3 t = new Ticket3();        Thread t1 = new Thread(t);        Thread t2 = new Thread(t);        Thread t3 = new Thread(t);        t1.setName("window t1");        t2.setName("window t2");        t3.setName("window t3");        t1.start();        t2.start();        t3.start();    }}class Ticket3 extends Thread {    private static int ticket = 100;    // 同步方法    private static synchronized void show() {  //    //private synchronized void show() { //同步监视器: t1,t2,t3。此种解决方式是错误的{        if (ticket > 0) {            try {                Thread.sleep(100);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println(Thread.currentThread().getName() + " ticket NO.: " + ticket--);        }    }    @Override    public void run() { // 同步监视器this        while (true) {            show();            if (ticket <= 0)                break;        }    }}

image-20210409235201436

image-20210409235220461

image-20210409235236246

image-20210409235250711

image-20210409235304413

image-20210409235320930

线程安全的单例模式——懒汉式

/** * @author brook * @create 2021-04-11 9:57 */public class SingletonTest {    public static void main(String[] args) {        Bank b1 = Bank.getInstance();        Bank b2 = Bank.getInstance();        System.out.println(b1 == b2);    }}class Bank {    private Bank(){}    private static Bank instance = null;    // 同步方法    public static synchronized Bank getInstance() {        if (instance == null)            instance = new Bank();        return instance;    }    // 更加有效率的写法//    public static Bank getInstance() {//        if (instance == null) {//            synchronized (Bank.class) {//                if (instance == null)//                    instance = new Bank();//            }//        }//        return instance;//    }}

image-20210409235558299

image-20210409235618183

死锁演示

/** * @author brook * @create 2021-04-12 11:03 */public class DeadLockTest {    public static void main(String[] args) {        final StringBuffer s1 = new StringBuffer();        final StringBuffer s2 = new StringBuffer();        new Thread() {            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() {            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();    }}

image-20210412221912091

image-20210412221936559

使用lock锁解决卖票问题

import java.util.concurrent.locks.ReentrantLock;/** * 解决线程安全问题的方式三: Lock锁--- JDK5.0 新增 * @author brook * @create 2021-04-12 17:11 */public class LockTest {    public static void main(String[] args) {        Ticket4 t = new Ticket4();        Thread t1 = new Thread(t);        Thread t2 = new Thread(t);        Thread t3 = new Thread(t);        t1.setName("window t1");        t2.setName("window t2");        t3.setName("window t3");        t1.start();        t2.start();        t3.start();    }}class Ticket4 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 {                        System.out.println(Thread.currentThread().getName() + " ticket NO.: " + ticket--);                        Thread.sleep(100);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            }finally {                // 3. 调用解锁方法unlock()                lock.unlock();            }        }    }}

面试题：synchronized 与lock的异同?

image-20210412222027080

image-20210412223159724

实现Runnable接口的方式

package exercise;/** *  银行有一个账户。 * 有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。 *          分析: * 1.是否是多线程问题?是，两个储户线程 * 2.是否有共享数据?有，账户（或账户余额) * 3.是否有线程安全问题?有 * 4.需要考虑如何解决线程安全问题?同步机制:有三种方式。 * * @author brook * @create 2021-04-12 22:47 */public class AccountTest {    public static void main(String[] args) {        Account a = new Account();        Thread t1 = new Thread(a);        Thread t2 = new Thread(a);        t1.setName("person 1");        t2.setName("person 2");        t1.start();        t2.start();    }}// 实现的方式class Account implements Runnable {    private int balance;    // 同步方法    @Override    public synchronized void run() {        for (int i = 0; i < 3; i++) {            try {                Thread.sleep(200);            	balance += 1000;            	System.out.println(Thread.currentThread().getName() + " : " + balance);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}

继承Thread类的方式

package exercise;/** * @author brook * @create 2021-04-12 23:41 */public class AccountTest1 {    public static void main(String[] args) {        Account1 acc = new Account1(0);        Customer c1 = new Customer(acc);        Customer c2 = new Customer(acc);        c1.setName("person 1");        c2.setName("person 2");        c1.start();        c2.start();    }}class Account1 {    private int balance;    public Account1(int balance) {        this.balance = balance;    }    public synchronized void deposit(int money) {        if (money > 0){            try {                Thread.sleep(200);                balance += money;            	System.out.println(Thread.currentThread().getName() + " : " + balance);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}// 继承Thread类的方式class Customer extends Thread {    private Account1 acc;    public Customer(Account1 acc) {        this.acc = acc;    }    @Override    public void run() {        for (int i = 0; i < 3; i++) {            acc.deposit(1000);        }    }}

交替存钱，使用wait()和notify()方法

package exercise;/** *  银行有一个账户。 * 有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。 *          分析: *  ******交替存钱的方式********** * * @author brook * @create 2021-04-12 22:47 */public class AccountTest {    public static void main(String[] args) {        Account a = new Account();        Thread t1 = new Thread(a);        Thread t2 = new Thread(a);        t1.setName("person 1");        t2.setName("person 2");        t1.start();        t2.start();    }}// 实现Rnnable接口的方式class Account implements Runnable {    private int balance = 0;    //同步代码块    @Override    public void run() {        for (int i = 0; i < 3; i++) {             synchronized (this) {                 notify();                 try {                     balance += 1000;                     System.out.println(Thread.currentThread().getName() + " deposit $1000，balance is " + balance);                     Thread.sleep(100);                 } catch (InterruptedException e) {                     e.printStackTrace();                 }                 try {                     wait();                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }         }    }}

8.5 线程的通信

image-20210413095408097

image-20210413100955834

image-20210413101042231

image-20210413101059588

image-20210413101117271

面试题：比较sleep()和wait()方法的异同？

1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。|
2.不同点:

​ 1）两个方法声明的位置不同: Thread类中声明sleep() , 0bject类中声明wait()；

​ 2）调用的要求不同: sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中；

​ 3）关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁；

image-20210413101137423

image-20210413101155494

image-20210413101233625

image-20210413101250382

image-20210413101311767

package threadstudy;/** * 经典例题: 生产者/消费者问题 * * @author brook * @create 2021-04-13 16:59 */public class ProducerConsumer {    public static void main(String[] args) {        Clerk clerk = new Clerk();        Thread p = new Thread(new Producer(clerk));        Thread c = new Thread(new Consumer(clerk));        p.setName("producer");        c.setName("customer");        p.start();        c.start();    }}class Clerk {    private int product = 0;    //生产产品    public synchronized void produce() {        if (product < 20) {            product++;            System.out.println(Thread.currentThread().getName()+": "+product);            notifyAll();        } else {            try {                wait();            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }    //消费产品    public synchronized void consume() {        if (product > 0)  {            System.out.println(Thread.currentThread().getName()+": "+product);            product--;            notifyAll();        } 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() {        while (true) {            try {                Thread.sleep(100);            } catch (InterruptedException e) {                e.printStackTrace();            }            clerk.produce();        }    }}//消费者class Consumer implements Runnable {    private Clerk clerk;    public Consumer(Clerk clerk) {        this.clerk = clerk;    }    @Override    public void run() {        while (true) {            try {                Thread.sleep(200);            } catch (InterruptedException e) {                e.printStackTrace();            }            clerk.consume();        }    }}

image-20210413101334526

image-20210413101453645

image-20210413101515732

image-20210413101538718

8.6 JDK5.0新增线程创建方式

image-20210413213923101

image-20210413213941109

package threadstudy;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;/** * 创建线程的方式三:实现callabLe接口。--- JDK 5.0新增 * * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大? * 1. call()可以有返回值的。 * 2. call()可以抛出异常，被外面的操作捕获，获取异常的信息 * 3. Callable是支持泛型的 * * @author brook * @create 2021-04-13 22:35 */public class ThreadNew {    public static void main(String[] args) {        // 3. 创建callable接口实现类的对象        NumThread numThread = new NumThread();        // 4. 将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象        FutureTask futureTask = new FutureTask(numThread);        // 5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法        new Thread(futureTask).start();        try {            // 6. 获取Callable中call方法的返回值            // get()返回值即为FutureTask构造器参数callable实现类重写的call()的返回值。            Object sum = futureTask.get();            System.out.println("sum is : " + sum);        } catch (InterruptedException e) {            e.printStackTrace();        } catch (ExecutionException e) {            e.printStackTrace();        }    }}// 1. 创建一个实现Callable的实现类class NumThread implements Callable {    // 2. 实现call方法，将此线程需要执行的操作声明在call()中    @Override    public Object call() throws Exception {        int sum = 0;        for (int i = 1; i <= 100 ; i++) {            if (i % 2 == 0){                System.out.println(i);                sum += i;            }        }        return sum;    }}

image-20210413213958160

image-20210413214014792

package threadstudy;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/** * 创建线程的方式四:使用线程池 * * 好处: * 1.提高响应速度（减少了创建新线程的时间) * 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建>) * 3.便于线程管理 *      corePooLsize:核心池的大小 *      maximumPooLsize:最大线程数 *      keepAliveTime:线程没有任务时最多保持多长时间后会终止 * * @author brook * @create 2021-04-13 23:23 */public class ThreadPool {    public static void main(String[] args) {        // 1．提供指定线程数量的线程池        ExecutorService service = Executors.newFixedThreadPool(10);//        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;//        service1.setCorePoolSize(15);//        service1.setKeepAliveTime();        // 2. 执行指定的线程的操作，需要提供实现Runnable接口或callable接口实现类的对象        service.execute(new NumberThread());  //适合使用于Runnable        service.execute(new NumberThread1());  //适合使用于Runnable        // 3. 关闭连接池        service.shutdown();//      service.submit(); //适合使用于Callable    }}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);        }    }}

复习题

1.画图说明线程的生命周期，以及各状态切换使用到的方法等状态，方法。

2.同步代码块中涉及到同步监视器和共享数据，谈谈你对同步监视器和共享数据的理解，以及注意点。

3.sleep()和wait()的区别？

1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。|
2.不同点:

​ 1）两个方法声明的位置不同: Thread类中声明sleep() , 0bject类中声明wait()；

​ 2）调用的要求不同: sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中；

​ 3）关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁；

4. 写一个线程安全的懒汉式

class Bank {    private static Bank instance;    private Bank() {}        public static Bank getInstance() {        if (instance == null) {            synchronized(Bank.class) {                if (instance == null)                    instance = new Bank();            }        }        return instance;    }}

5. 创建多线程有哪几种方式？

1）继承Thread类

2）实现Runna接口

3）实现Callable接口

4）使用线程池

点个推荐再走吧
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/victorxiao/p/14657029.html