JavaseLearn18-多线程

1.多线程概述

1.1 什么是进程？什么是线程？

进程是一个应用程序
线程是一个进程中的执行场景/执行单元
一个进程可以启动多个线程

对于一个java程序来说，当开始执行后，会先启动JVM，而JVM就是一个进程。

JVM再启动一个主线程调用main方法，同时再启动一个垃圾回收线程负责看护，回收垃圾。故一个java程序起码有两个线程并发。

1.2进程与线程的关系

举个栗子：

美团：进程
- 王兴：线程
- 外卖小哥：线程
阿里巴巴：进程
- 马云：线程
- 保安：线程

进程可看作是一个公司。

线程可看作是公司里的一名员工。

注意：

进程A与进程B之间内存独立不共享(如美团和阿里巴巴资源是不共享的)。
一个线程一个栈。
线程A与线程B之间，堆内存和方法区内存共享，但是栈内存互相独立。

1.3多线程并发

假设启动10个线程，就会开辟10个栈空间，每个栈之间互不干扰，各自执行各自的，这就是多线程并发。

1.3.1举个栗子：

学校食堂可以看作是一个进程，

食堂里每一个窗口可以看作是一个线程，

我在A窗口打饭，你可以在B窗口打饭，你不需要等我，我也不需要等你。

故多线程并发可以提高效率。

Java中之所以有多线程机制，目的就是为了提高程序的处理效率。

注意：

使用了多线程机制后，main方法结束，有可能程序也不会结束。

main方法结束只代表主线程结束了，主栈空了，其他的栈(线程)可能还在压栈弹栈。

1.3.2思考问题：

对于单核的cpu来说，可以做到真正多线程并发吗？

什么是真正的多线程并发？

t1线程执行t1的，t2执行t2的，t1不会影响到t2，t2也不会影响t1。

这就是真正的多线程并发。

对于单核的cpu来说只有一个大脑，无法做到真正的多线程并发，但可以给人一种"多线程并发的感觉"。

在某一个时间点上，单核的cpu只能执行一个线程，但是由于cpu执行速度极快，通过频繁切换不同的线程，给人一种同时处理多个线程的感觉。

就好比你在玩炉石，同时后台用网易云播放着"蜜雪冰城甜蜜蜜"。

线程A:炉石

线程B:网易云"蜜雪冰城甜蜜蜜"

线程A和线程B频繁切换运行，你就感觉游戏一直在运行，音乐一直在播放。

1.5分析程序存在几个线程

以下程序中有几个线程?

/**
 * @Author: TSCCG
 * @Date: 2021/06/18 17:41
 */
public class ThreadDemo01 {
    public static void main(String[] args) {
        System.out.println("main begin");
        t1();
        System.out.println("main over");
    }

    private static void t1() {
        System.out.println("t1 begin");
        t2();
        System.out.println("t1 over");
    }

    private static void t2() {
        System.out.println("t2 begin");
        t3();
        System.out.println("t2 over");
    }

    private static void t3() {
        System.out.println("t3执行!");
    }
}

答：除垃圾回收外，只有一个main主线程，主栈

理由：没有启动分支栈，没有启动分支线程，故只有一个主线程，一个栈

结果：

main begin
t1 begin
t2 begin
t3执行!
t2 over
t1 over
main over

程序线程数

2.实现线程的方式

若要开启一条新的线程，必须要用到start()方法和run方法

start方法：

启动一个分支线程，在JVM中开辟一块新的栈空间，启动完后立即结束运行start方法

run()方法:

run()方法需要在分支栈里重写，地位相当于主栈中的main()方法。
启动成功的线程会自动调用run方法，run方法在分支栈的最底部(压栈)。
main方法在主栈的最底部，run方法在分支栈的最底部，两者是平级的

2.1第一种"^_"

实现线程的第一种方法：

写一个继承Thread类的类，重写run方法。

使用时创建一个线程对象，然后调用start()方法。

/**
 * @Author: TSCCG
 * @Date: 2021/06/18 20:02
 */
public class ThreadDemo02 {
    //main方法，属于主线程，运行在主栈中
    public static void main(String[] args) {
        //创建一个分支线程对象
        MyThread01 myThread = new MyThread01();
        //启动线程,启动完后立即结束start方法
        myThread.start();
        //此处如果没有调用start方法，直接调用run方法，程序仍然只有一个线程
        //因为没有开启新的线程，相当于是调用了一个普通方法
        //myThread.run();
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程---->" + i);
        }
    }
}
 class MyThread01 extends Thread{
    /**
     * 此处重写的run方法相当于主线程里的main
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("分支线程---->" + i);
        }
    }
}

结果：

主线程---->0
分支线程---->0
分支线程---->1
分支线程---->2
主线程---->1
分支线程---->3
分支线程---->4
主线程---->2
分支线程---->5
主线程---->3
主线程---->4
分支线程---->6
分支线程---->7
分支线程---->8
分支线程---->9
主线程---->5
主线程---->6
主线程---->7
主线程---->8
主线程---->9

2.2第二种T_T

创建线程的第二种方法：

写一个实现Runnable接口的类，叫可执行类

使用时将该类的实例对象作为参数传入Thread类里，转换成线程对象，然后通过该线程对象调用start()方法

/**
 * @Author: TSCCG
 * @Date: 2021/06/19 09:29
 */
public class ThreadDemo03 {
    public static void main(String[] args) {
        //创建一个可运行类
        MyRunnable r = new MyRunnable();
        //将可运行类的对象作为参数传入Thread类的构造方法里，转换成线程对象
        Thread t = new Thread(r);//也可以这样写：Thread t2 = new Thread(new MyRunnable());
        //开辟一个分支栈，开启分支线程
        t3.start();
    }
}
 class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("分支线程---->" + i);
        }
    }
}

也可以采用匿名内部类方式

Thread t3 = new Thread(new Runnable() {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("分支线程---->" + i);
        }
    }
});
t3.start();

3.线程生命周期

一个线程的周期一共分为五个状态：

新建状态----线程对象刚被new出来
就绪状态----调用start方法后，开辟了栈空间，表示具有抢夺CPU时间片的权力(执行权)。一旦一个线程抢到了CPU时间片，就开始执行run方法。
运行状态----run方法的开始执行，表示该线程进入了运行状态。当用完之前抢到的CPU时间片后，会重新回到就绪状态继续抢夺CPU时间片，当该线程再次抢到CPU时间片后，会重新进入run方法，接着之前的代码运行。
阻塞状态----当一个线程遇到如用户键盘输入、sleep方法等阻塞事件时，线程就会进入阻塞状态，放弃之前占有的CPU时间片，当结束阻塞状态时，再次回到就绪状态
死亡状态----当线程的main或run方法执行完后，就会进入死亡状态

一个线程进入阻塞状态，其他线程可能继续运行。

import java.util.Scanner;

/**
 * @Author: TSCCG
 * @Date: 2021/06/19 09:29
 */
public class ThreadDemo03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //创建线程对象
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("分支线程---->" + i);
                }
            }
        });
        //开启分支线程
        t3.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程---->" + i);
            //放置一个阻塞事件，当i == 5时，主线程阻塞，分支线程继续执行，
            //当输入一个整数时，阻塞事件结束，主线程继续运行
            if(i == 5){
                System.out.println("遭遇阻塞事件");
                int j = sc.nextInt();
                System.out.println("阻塞事件结束");
            }
        }

    }
}

结果：

主线程---->0
主线程---->1
主线程---->2
主线程---->3
主线程---->4
分支线程---->0
分支线程---->1
分支线程---->2
分支线程---->3
分支线程---->4
分支线程---->5
主线程---->5
遭遇阻塞事件
分支线程---->6
分支线程---->7
分支线程---->8
分支线程---->9
3
阻塞事件结束
主线程---->6
主线程---->7
主线程---->8
主线程---->9

4.线程的常用方法

4.1获取当前线程对象

静态方法，通过Thread来调用

Thread t = Thread.currentThread();

4.2获取当前线程名字

String name = 线程对象.getName();

默认情况下，线程的名字默认为:

Thread-0

Thread-1

Thread-2

4.3修改当前线程名字

线程对象.setName("线程名字");

案例：

/**
 * @Author: TSCCG
 * @Date: 2021/06/19 10:27
 */
public class ThreadDemo04 {
    public static void main(String[] args) {
        //创建线程对象t1
        MineThread t1 = new MineThread();
        //设置线程t1的名字
        t1.setName("t1");
        //开启线程t1
        t1.start();

        //创建线程对象t2
        MineThread t2 = new MineThread();
        t2.setName("t2");
        t2.start();

        for (int i = 0; i < 10; i++) {
            //获取当前线程对象
            Thread t = Thread.currentThread();
            //获取当前线程对象
            System.out.println(t.getName() + "---->" + i);
        }
    }
}
class MineThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //获取当前线程对象
            Thread t = Thread.currentThread();
            //获取当前线程对象
            System.out.println(t.getName() + "---->" + i);
        }
    }
}

结果：

main---->0
main---->1
main---->2
main---->3
t2---->0
t1---->0
t1---->1
t2---->1
t2---->2
main---->4
t2---->3
t1---->2
t2---->4
main---->5
t2---->5
t1---->3
t2---->6
main---->6
t2---->7
t1---->4
t2---->8
t2---->9
main---->7
t1---->5
t1---->6
main---->8
t1---->7
main---->9
t1---->8
t1---->9

4.4 sleep()方法

4.4.1 作用及用法

static void sleep(long millis)

1.静态方法：Thread.sleep(1000);

2.单位是1毫秒

3.作用：让当前线程进入休眠，进入"阻塞状态",放弃占有CUP时间片,让给其他线程使用

注意：

Thread.sleep(1000);出现在哪个线程，哪个线程就会进入休眠

例：

/**
 * @Author: TSCCG
 * @Date: 2021/06/19 10:55
 */
public class ThreadDemo05 {
    public static void main(String[] args) {
        System.out.println("让子弹飞一会儿");
        try {
            Thread.sleep(1000 * 5);//让主线程休眠5s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);//每次休眠1s
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("砰！---->" + i);
        }
    }
}

结果：

让子弹飞一会儿
砰！---->0
砰！---->1
砰！---->2
砰！---->3
砰！---->4
砰！---->5
砰！---->6
砰！---->7
砰！---->8
砰！---->9

4.4.2 sleep()面试题

判断以下程序中t1线程是否会休眠2s?

/**
 * @Author: TSCCG
 * @Date: 2021/06/27 15:43
 * sleep()面试题
 */
public class ThreadDemo06 {
    public static void main(String[] args) {

        Thread t1 = new MineThread02();
        t1.start();
        t1.setName("t1");
        try {
            //这里使用线程对象t1调用sleep()方法
            t1.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("HelloWorld!");

    }
}
class MineThread02 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            Thread t = Thread.currentThread();
            System.out.println(t.getName() + "---->" + i);
        }
    }

}

结果：

t1---->0
t1---->1
t1---->2
t1---->3
t1---->4
t1---->5
t1---->6
t1---->7
t1---->8
t1---->9
HelloWorld!

从结果可见，通过线程对象t1调用sleep()方法后，t1线程并没有休眠，而是主线程休眠2s。

为什么呢？

这是因为sleep()是静态方法，不应该通过类对象来调用，只能通过类'Thread'直接访问。

t1.sleep(2000);这句代码实际执行的是Thread.sleep(2000);

4.4.3 中断线程的休眠

通过调用interrupt()方法可以中断程序的休眠

/**
 * @Author: TSCCG
 * @Date: 2021/06/27 11:23
 */
public class ThreadDemo07 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable02());
        t.setName("t");
        t.start();
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //在主线程休眠5s后，将t线程唤醒
        t.interrupt();
    }
}
class MyRunnable02 implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "----> begin");
        //在run()方法中，只能通过try...catch处理异常，而不能用throws将异常抛出
        //因为run()方法在父类中没有抛出任何异常，而子类不能抛出更多的异常
        try {
            //使分支线程休眠1年
            Thread.sleep(1000 * 60 * 60 * 24 * 365);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "----> end");

    }
}

结果：

在打印"t----> begin" 五秒后打印线程休眠中断异常信息，然后打印"t----> end"

t----> begin
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at MyRunnable02.run(ThreadDemo07.java:28)
	at java.lang.Thread.run(Thread.java:745)
t----> end

4.4.4 终止线程的执行

/**
 * @Author: TSCCG
 * @Date: 2021/06/28 11:41
 * 终止线程的执行
 */
public class ThreadDemo08 {
    public static void main(String[] args) {
        MyRunnable03 r = new MyRunnable03();
        Thread t = new Thread(r);
        t.setName("t");
        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        t.stop(); 拔电源，丢失数据,已过时
        r.isRun = false;//合理关闭，保存数据

    }
}
class MyRunnable03 implements Runnable{
    //定义一个boolean变量
    boolean isRun = true;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (isRun) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "--->" + i);
            } else {
                return;
            }
        }
    }
}

5. 线程调度

5.1 常见的线程调度模型

抢占式调度模型
- 哪个线程的优先级比较高，抢到的CPU时间片的概论就高一些/多一些。(不完全是，大概率是较多的)
- java采用的就是抢占式调度模型，线程最低优先级为1，最高优先级为10，默认优先级为5。
均分式调度模型
- 平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
- 平均分配，一切平等。

5.2 java中与线程调度有关的方法

方法名	作用
void setPriority(int newPriority)	设置此线程的优先级
int getPriority()	返回此线程的优先级
static void yield()	让位方法。暂停当前正在执行的线程对象(不是将线程阻塞，是让其回到就绪状态)，并执行其他线程
void join()	合并线程。在线程A中通过线程B的实例对象调用join()方法，线程A进入阻塞，线程B执行。直到线程B结束，线程A才能继续执行。相当于把线程B合并进线程A中。

5.2.1 线程优先级

线程最低优先级为1，最高优先级为10，默认优先级为5

哪个线程的优先级比较高，抢到的CPU时间片的概论就高一些/多一些，处于运行状态的时间多一些。(不完全是，大概率方向是偏于优先级高的)

查看优先级的方法：

/**
 * @Author: TSCCG
 * @Date: 2021/06/28 19:22
 */
public class ThreadDemo09 {
    public static void main(String[] args) {
        System.out.println("线程最大优先级为：" + Thread.MAX_PRIORITY);
        System.out.println("线程普通优先级为：" + Thread.NORM_PRIORITY);
        System.out.println("线程最小优先级为：" + Thread.MIN_PRIORITY);
		//获取当前线程优先级
        Thread currentThread = Thread.currentThread();
        System.out.println(currentThread.getName() + "线程默认的优先级为：" + currentThread.getPriority());
        Thread t = new Thread(new MyRunnable04());
        t.setName("t");
        t.start();
    }
}
class MyRunnable04 implements Runnable {

    @Override
    public void run() {
        //获取当前线程对象
        Thread currentThread = Thread.currentThread();
        //打印当前线程的优先级
        System.out.println(currentThread.getName() + "线程默认的优先级为：" + currentThread.getPriority());
    }
}

结果：

线程最大优先级为：10
线程普通优先级为：5
线程最小优先级为：1
main线程默认的优先级为：5
t线程默认的优先级为：5

优先级高的线程只是抢占的时间片较多一些，不是抢着不放一直执行。例：

/**
 * @Author: TSCCG
 * @Date: 2021/06/28 19:22
 */
public class ThreadDemo09 {
    public static void main(String[] args) {
        //获取主线程对象
        Thread currentThread = Thread.currentThread();
        Thread t = new Thread(new MyRunnable04());
        t.setName("t");
        t.start();
        //设置主线程的优先级为1
        currentThread.setPriority(1);
        //设置t线程的优先级为10
        t.setPriority(10);
        for (int i = 0; i < 10; i++) {
            System.out.println(currentThread.getName() + "--->" + i);
        }
    }
}
class MyRunnable04 implements Runnable {

    @Override
    public void run() {
        //获取当前线程对象
        Thread currentThread = Thread.currentThread();
        for (int i = 0; i < 10; i++) {
            System.out.println(currentThread.getName() + "--->" + i);
        }
    }
}

结果：

由结果来看，大概率方向更偏于优先级更高的

main--->0
t--->0
t--->1
t--->2
t--->3
t--->4
t--->5
t--->6
t--->7
t--->8
t--->9
main--->1
main--->2
main--->3
main--->4
main--->5
main--->6
main--->7
main--->8
main--->9

5.2.2 线程让位

static void yield()

静态方法，Thread.yield()。

暂停当前正在执行的线程对象，并执行其他线程。

不是将线程阻塞，是让其回到就绪状态。

让位后有可能再次抢到时间片。

/**
 * @Author: TSCCG
 * @Date: 2021/06/29 16:09
 */
public class ThreadDemo10 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable05());
        t.setName("t");
        t.start();
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}
class MyRunnable05 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            //每隔5个让一次
            if (i % 5 == 0) {
                //当前线程暂停一下，让给主线程
                Thread.yield();
            }
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

结果：

main--->0
t--->0
main--->1
t--->1
main--->2
main--->3
main--->4
t--->2
main--->5
t--->3
main--->6
t--->4
main--->7
t--->5
main--->8
t--->6
t--->7
t--->8
t--->9
main--->9
t--->10
main--->10
t--->11
main--->11
t--->12
main--->12
t--->13
main--->13
t--->14
t--->15
t--->16
main--->14
t--->17
main--->15
t--->18
main--->16
t--->19
main--->17
main--->18
main--->19

运行结果理应t线程每隔5个让给主线程一次。

但由于yield()让位方法不是将线程阻塞，而是让其回到就绪状态。让位后有可能再次抢到时间片。

故从结果来看，让位不明显

5.2.3 线程合并

调用join()方法。

将t线程合并到当前线程中，当前线程阻塞，直到t线程结束才能继续运行
在内存上并不是真的把两个栈合并了，只是两个栈之间发生等待关系。

/**
 * @Author: TSCCG
 * @Date: 2021/06/29 16:34
 */
public class ThreadDemo11 {
    public static void main(String[] args) {
        System.out.println("main--->Begin");
        Thread t = new Thread(new MyRunnable06());
        t.setName("t");
        t.start();
        try {
            //将t线程合并到当前线程中，当前线程阻塞，直到t线程结束才能继续运行
            //在内存上并不是真的把两个栈合并了，只是两个栈之间发生等待关系。
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main--->over");
    }
}
class MyRunnable06 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

结果：

main--->Begin
t--->0
t--->1
t--->2
t--->3
t--->4
t--->5
t--->6
t--->7
t--->8
t--->9
main--->over

6.线程安全

在多线程并发的环境下，数据的安全问题是重点。

6.1 为什么说线程安全是重点？

在开发过程中，我们的项目都是运行在服务器中，而服务器已经将线程的定义、线程对象的创建、线程的启动等都实现完了。我们不需要编写这些代码。

重要的是：我们编写的程序需要放到一个多线程的环境下运行，我们更需要关注的是这些数据在多线程并发的环境下是否是安全的。

6.2 线程安全问题

6.2.1 银行例子

假如有一个银行账户里存有10000元，张三和李四同时在两个取款机里从该账户中取出10000元。

张三先一步读取到了账户余额，取出10000元，然后对账户余额进行更新。但由于网络延迟，未能及时更新。

此时，李四读取了账户余额，得到的是未能及时更新的数据，也就是10000元，然后李四同样取出10000元。

张三和李四共计取出20000元，这是不合理的，银行账户的余额数据是不安全的。

代码：

银行账户类：

package ThreadSafe02;

/**
 * @Author: TSCCG
 * @Date: 2021/06/29 17:12
 * 银行账户类
 */
public class Account {
    //账号
    private String accountNumber;
    //余额
    private double balance;

    public Account() {

    }
    public Account(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    /**
     * 取钱
     */
        public void withdraw(double money) {
        //取之前的余额
        double before = this.balance;
        //取之后的余额
        double after = before - money;
        //在这里模拟一下网络延迟，100%会出问题
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //更新余额
      //t1执行到这里了，但还没来得及执行下面这行代码，此时t2线程进入withdraw方法开始执行，一定会出问题。
        this.balance = after;
    }

    public String getAccountNumber() {
        return accountNumber;
    }

    public double getBalance() {
        return balance;
    }
}

线程类：

package ThreadSafe02;


/**
 * @Author: TSCCG
 * @Date: 2021/06/29 17:36
 * 使用多线程并发来对同一个账户取款，是不安全的
 */
public class AccountThread extends Thread{
    /**
     * 当创建多个线程时，共享一个账户
     */
    private final Account act;

    /**
     * 通过构造方法来将账户对象传递过来
     * @param act 传递过来的账户对象
     */
    public AccountThread(Account act) {
        this.act = act;
    }

    /**
     * 在run方法的执行表示取款操作
     */
    @Override
    public void run() {
        double money = 10000;
        //取款
        act.withdraw(money);
        System.out.println(Thread.currentThread().getName() + "对账户"
                + act.getAccountNumber() + "取款" + money +"成功，余额剩余："
                + act.getBalance());
    }
}

测试类：

package ThreadSafe02;


/**
 * @Author: TSCCG
 * @Date: 2021/06/29 17:44
 */
public class AccountTest02 {
    public static void main(String[] args) {
        //初始化银行账户
        Account act = new Account("act-001",10000);
        //创建两个线程对象
        AccountThread t1 = new AccountThread(act);
        AccountThread t2 = new AccountThread(act);
        t1.setName("t1");
        t2.setName("t2");
        //开启两个线程，开始取款
        t1.start();
        t2.start();
    }
}

运行结果：

t1对账户act-001取款10000.0成功，余额剩余：0.0
t2对账户act-001取款10000.0成功，余额剩余：0.0

6.2.2 总结线程不安全的条件

该例子中，张三和李四同时进行取款操作，可看作是线程A和线程B并发，同一个银行账户里的余额是两个线程的共享数据，线程A和线程B都对共享数据进行了修改操作。

从而可总结出线程不安全的条件：

多线程并发
有共享数据
共享数据有修改操作

6.2.3 有线程安全问题的变量

java三大变量：

实例变量
- 在堆中，堆只有一个，多线程共享
- 可能存在线程安全问题。
局部变量
- 在栈中，一个线程一个栈，局部变量不共享。
- 永远都不会存在线程安全问题。
静态变量
- 在方法区中，方法区只有一个，多线程共享。
- 可能存在线程共享问题。

如果使用局部变量的话，建议使用StringBuilder，因为局部变量不会存在线程安全问题。StringBuffer虽然时线程安全的，但是效率较低。

StringBuilder是非线程安全的
StringBuffer是线程安全的
ArrayList是非线程安全的
Vector是线程安全的
HashMap是非线程安全的
HashTable是线程安全的

6.3 解决线程安全问题

6.3.1 同步编程模型和异步编程模型

同步编程模型：
- 线程t1和线程t2，在线程t1执行的时候，线程t2必须等待，线程t1执行结束后，t2才能执行。反之亦然。
- 线程排队
- 效率较低
异步编程模型：
- 线程t1和线程t2，各自执行各自的，互不干扰
- 多线程并发
- 效率较高

同步就是排队，异步就是并发。

6.3.2 同步代码块synchronized

让线程排队执行，就可以解决线程安全问题。

这种机制被称为：线程同步机制。

线程同步机制会牺牲一部分效率，但能保障数据安全。

线程同步机制的语法：

synchronized(){
     //线程同步代码块
}

上面银行账户例子中，若想实现账户余额数据安全，withdraw方法中的代码必须是线程排队的，不能并发

public void withdraw(double money) {
    //取之前的余额
    double before = this.balance;
    //取之后的余额
    double after = before - money;
    //在这里模拟一下网络延迟，100%会出问题
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    //更新余额
    //t1执行到这里了，但还没来得及执行下面这行代码，此时t2线程进入withdraw方法开始执行，一定会出问题。
    this.balance = after;
}

使用synchronized改进代码：

public void withdraw(double money) {
    //this是多线程共享对象
    synchronized (this){
        //取之前的余额
        double before = this.balance;
        //取之后的余额
        double after = before - money;
        //网络延迟1s
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //更新余额
        this.balance = after;
    }
}

结果：

t1对账户act-001取款10000.0成功，余额剩余：0.0
t2对账户act-001取款10000.0成功，余额剩余：-10000.0

6.3.3 深入理解synchronized

1.小括号里填什么？

synchronized后面小括号里传的"数据"是至关重要的。
这个数据必须是多线程共享的数据才能达到多线程排队的效果。

假设有t1，t2，t3，t4，一共四个线程，
我们只希望t1、t2和t3排队，t4不需要排队，
就必须在synchronized后面的小括号内写一个t1，t2，t3共享的对象，
而这个对象对于t4来说是不共享的。

上面例子中，共享对象是：账户对象，
账户对象是共享的，故我们可以在小括号里填this。
不一定非要填this，只要是多线程共享的对象都可以。

比如我们在银行账户类Account里添加一个实例对象：Object obj1 = new Object();

obj1是一个实例对象。Account对象是多线程共享的，Account对象中的实例变量obj1也是共享的。

故将obj1填入小括号里，同样可以达到同步效果。
但如果我们在withdraw方法中添加一个局部对象：Object obj2 = new Object();就不能达到线程同步效果。原因是局部对象的引用存于栈中，每当一个线程执行withdraw方法，就会new一个obj2，每个线程都有各自的obj2，obj2不是线程共享的对象，所以不能达到同步效果。
将"abc"填入小括号内，同样会达到线程同步效果。

"abc"在字符串常量池中，所有线程都共享。

但这样会导致所有线程都会同步，效率降低。就好比上公共厕所，强制所有人都在一个空位上排队，在一个人使用结束之前，其他所有人都得排队。

package ThreadSafe02;

/**
 * @Author: TSCCG
 * @Date: 2021/06/29 17:12
 * 银行账户类
 *  使用线程同步机制，解决线程安全问题
 */
public class Account {
    //账号
    private String accountNumber;
    //余额
    private double balance;
    //一个实例对象
    Object obj1 = new Object();
    public Account() {

    }
    public Account(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }
    /**
     * 取钱
     */
    public void withdraw(double money) {
        Object obj2 = new Object();
        synchronized (this){
//        synchronized (obj1) { //obj1是一个实例对象。Account对象是多线程共享的，Account对象中的实例变量obj1也是共享的。
//        synchronized (obj2) {//obj2是一个局部对象，多线程不共享
//        synchronized (null){//空指针异常
//        synchronized ("abc"){//"abc"在字符串常量池中，所有线程都共享
            //取之前的余额
            double before = this.balance;
            //取之后的余额
            double after = before - money;
            //网络延迟1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //更新余额
            this.balance = after;
        }
    }
    public String getAccountNumber() {
        return accountNumber;
    }

    public double getBalance() {
        return balance;
    }
}

2.使用synchronized改进代码后的执行过程：

java中每一个对象都有一把”锁“，其实这把锁就是标记。只是把它叫做锁。

t1,t2并发执行，但总有一先一后。
假设t1先遇到了synchronized，就会去寻找小括号里"共享对象"的"锁"，
t1找到后，如果共享对象的锁未被其他线程占有，那么t1就会将其占有，
然后执行synchronized中的同步代码块，期间t1一直占有共享对象的锁，
直到同步代码块执行完，t1才会释放这把锁。
假设在t1执行同步代码块期间，t2也遇到了synchronized，
同样会去占有小括号内共享对象的锁。
但发现此时这把锁正由t1所占有，t2只能在同步代码块外面等待，
直到t1将同步代码块执行结束后将锁释放，t2才能够将锁占据。
然后t2同样开始执行同步代码块。
如此就实现了线程排队执行。
这里需要注意的是，这个共享对象一定要选对，一定是需要排队执行的这些线程对象所共享的。

6.3.4 synchronized的三种写法

1.同步代码块

synchronized(){
     //线程同步代码块
}

2.在实例方法上使用synchronized

在实例方法上使用后，共享对象一定是this，并且同步代码块是整个方法体。

public synchronized void withdraw(double money) {
    
}

3.在静态方法上使用synchronized

线程执行到此，找的是类锁。

类锁永远只有一把。

就算创建了100个对象，类锁也只有一把。

public synchronized static void withdraw(double money) {
    
}

注意：

对象锁：1个对象1把锁，100个对象100把锁。
类锁：100个对象，也可能只有一把类锁。

6.3.5 synchronized面试题

面试题1：

doOther方法执行的时候需要等待doSome方法的结束吗？

package example.example01;

/**
 * @Author: TSCCG
 * @Date: 2021/06/29 20:59
 */
public class Example01 {
    public static void main(String[] args) {
        MyClass01 mc = new MyClass01();
        MyThread01 t1 = new MyThread01(mc);
        MyThread01 t2 = new MyThread01(mc);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        //让当前线程睡眠1s，延迟执行t2线程，以保证t1能够先执行
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();

    }
}
class MyThread01 extends Thread {
    MyClass01 mc;
    public MyThread01(MyClass01 mc) {
        this.mc = mc;
    }
    @Override
    public void run() {
        if ("t1".equals(Thread.currentThread().getName())) {
            mc.doSome();
        } else if ("t2".equals(Thread.currentThread().getName())) {
            mc.doOther();
        }
    }
}
class MyClass01 {
    public synchronized void doSome() {
        System.out.println("doSome-->begin");
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome-->over");
    }
    public void doOther() {
        System.out.println("doOther-->begin");
        System.out.println("doOther-->over");
    }
}

结果：

doSome-->begin
doOther-->begin
doOther-->over
doSome-->over

分析：

执行过程：

线程t1先执行，线程t2 1秒钟后执行。
线程t1在执行run方法时，通过if判断而执行doSome方法，

因doSome方法是由synchronized修饰的，故线程t1寻找this对象的锁并将其占据，

然后打印：

doSome-->begin，

接着遇到sleep方法，休眠5秒。
此时，线程t2通过if判断开始执行doOther方法，

由于doOther方法没有被synchronized修饰，所以线程t2不需要占据this对象锁，

直接打印:

doOther-->begin
doOther-->over
5秒后，线程t1结束休眠，

接着打印：

doSome-->over

在本题中，两个线程t1和t2分别只执行doSome方法和doOther方法，而只有doSome方法被synchronized修饰，

所以只有线程t1在执行时需要占有this对象锁，线程t2不需要。

故未能实现线程同步，两个线程并发执行，doOther方法执行的时候不需要等待doSome方法的结束。

面试题2：

使用synchronized修饰面试题1中doOther方法，其他不变。

此时，doOther方法执行的时候需要等待doSome方法的结束吗？

//需要占据this的锁
public synchronized void doSome() {
    System.out.println("doSome-->begin");
    try {
        Thread.sleep(1000 * 5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("doSome-->over");
}
//也需要占据this的锁
public synchronized void doOther() {
    System.out.println("doOther-->begin");
    System.out.println("doOther-->over");
}

结果：

doSome-->begin
doSome-->over
doOther-->begin
doOther-->over

分析：

在本题中，doSome方法和doOther方法都由synchronized所修饰。

两个线程在执行两个方法时都需要占有this对象锁，而this对象是两个线程所共享的。

故实现了线程同步，两个线程排队执行，doOther方法执行的时候需要等待doSome方法的结束。

面试题3：

在面试题2中，new两个MyClass01对象，mc1和mc2，分别传入线程t1和线程t2中，其他不变。

此时，doOther方法执行的时候需要等待doSome方法的结束吗？

public class Example01 {
    public static void main(String[] args) {
        MyClass01 mc1 = new MyClass01();
        MyClass01 mc2 = new MyClass01();
        MyThread01 t1 = new MyThread01(mc1);
        MyThread01 t2 = new MyThread01(mc2);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        //保证t1能够先执行
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();

    }
}

class MyThread01 extends Thread {
    MyClass01 mc;
    public MyThread01(MyClass01 mc) {
        this.mc = mc;
    }
    @Override
    public void run() {
        if ("t1".equals(Thread.currentThread().getName())) {
            mc.doSome();
        } else if ("t2".equals(Thread.currentThread().getName())) {
            mc.doOther();
        }
    }
}

class MyClass01 {
    public synchronized void doSome() {
        System.out.println("doSome-->begin");
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome-->over");
    }
    public synchronized void doOther() {
        System.out.println("doOther-->begin");
        System.out.println("doOther-->over");
    }
}

结果：

doSome-->begin
doOther-->begin
doOther-->over
doSome-->over

分析：

在本题中，doSome方法和doOther方法都由synchronized所修饰。

两个线程在执行两个方法时都需要占有this对象锁，

但线程t1的this对象是mc1，线程t2的this对象是mc2，对象不共享。

没有实现线程同步，两个线程并发执行，doOther方法执行的时候不需要等待doSome方法的结束。

面试题4：

将面试题3中doSome方法和doOther方法都改为静态方法，其他不变。

doOther方法执行的时候需要等待doSome方法的结束吗？

public class Example01 {
    public static void main(String[] args) {
        MyClass01 mc1 = new MyClass01();
        MyClass01 mc2 = new MyClass01();
        MyThread01 t1 = new MyThread01(mc1);
        MyThread01 t2 = new MyThread01(mc2);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        //保证t1能够先执行
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();

    }
}

class MyThread01 extends Thread {
    MyClass01 mc;
    public MyThread01(MyClass01 mc) {
        this.mc = mc;
    }
    @Override
    public void run() {
        if ("t1".equals(Thread.currentThread().getName())) {
            MyClass01.doSome();
        } else if ("t2".equals(Thread.currentThread().getName())) {
            MyClass01.doOther();
        }
    }
}

class MyClass01 {
    //静态方法，类锁
    public synchronized static void doSome() {
        System.out.println("doSome-->begin");
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome-->over");
    }
    public synchronized static void doOther() {
        System.out.println("doOther-->begin");
        System.out.println("doOther-->over");
    }
}

结果：

doSome-->begin
doSome-->over
doOther-->begin
doOther-->over

分析：

在本题中，doSome方法和doOther方法都由synchronized所修饰。

因为两个方法都是静态方法，所以两个线程在执行两个方法时都需要占有MyClass01类锁。

虽然new了两个对象，但MyClass01类锁只有一把。

故实现了线程同步，两个线程排队执行，doOther方法执行的时候需要等待doSome方法的结束。

6.3.6 在实际开发中应该怎么解决线程安全问题

我们处理线程安全问题时，一般有三种方案。

第一种：尽量使用局部变量代替"实例变量和静态变量"。
第二种：如果必须使用局部变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。(一个线程对应一个对象，100个线程对应100个对象，对象不共享，就不会存在数据安全问题了)
第三种：在不能使用局部变量，同时不能创建多个对象的情况下，才使用synchronized线程同步机制。

注意：

我们不应该一上来就选择线程同步。synchronized会让程序的执行效率降低，用户体验不好，系统的用户吞吐量降低。在不得已的情况下再选择线程同步机制。

6.4死锁

所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。

如下例子：

线程t1按照先锁对象1，再锁对象2的顺序执行。

线程t2按照先锁对象2，再锁对象1的顺序执行。

当两个线程同时开始执行时，

线程t1先一步锁了对象1，线程t2先一步锁了对象2，

此时，线程t1无法锁对象2，线程t2无法锁对象1，两个线程都等待对方释放锁，程序僵持在那里。

这种情况即不会出现异常，也不会出现错误，最难调试。

代码实现：

package deadlock;

/**
 * @Author: TSCCG
 * @Date: 2021/06/30 17:56
 * 死锁
 * synchronized在开发中，最好不要嵌套使用，一不小心就会发生死锁现象
 */
public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        MyThread01 t1 = new MyThread01(o1,o2);
        MyThread02 t2 = new MyThread02(o1,o2);
        t1.start();
        t2.start();

    }
}
class MyThread01 extends Thread {
    final Object o1;
    final Object o2;

    public MyThread01(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2) {

            }
        }
    }
}
class MyThread02 extends Thread {
    final Object o1;
    final Object o2;

    public MyThread02(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o2) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1) {

            }
        }
    }
}

7.守护线程

7.1 什么是守护线程？

java中线程分两大类：

用户线程
守护线程(后台线程)
- 最具代表性的就是垃圾回收线程

守护线程的特点：

一般守护线程是一个死循环，所有的用户线程只要结束，守护线程就会自动结束。

注意：主线程main是一个用户线程。

7.2 守护线程用在什么地方呢？

每天00:00的时候系统数据自动备份。

这个需要用到定时器，并且我们可以将定时器设置为守护线程。

一直在那里看着，每到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。

7.3 实现一个守护线程：

调用setDaemon(true);

package proThread;

/**
 * @Author: TSCCG
 * @Date: 2021/06/30 21:37
 */
public class ThreadDemo01 {
    public static void main(String[] args) {
        BackThread t1 = new BackThread();
        t1.setName("备份数据线程");
        //设置线程t1为守护线程，必须放在线程启动之前
        //用户线程一结束，守护线程跟着也会结束
        t1.setDaemon(true);
        t1.start();

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class BackThread extends Thread {
    @Override
    public void run() {
        int i = 0;
        //设置一个死循环
        while (true) {
            System.out.println(Thread.currentThread().getName() + "--->" + ++i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

结果：

main--->0
备份数据线程--->1
main--->1
备份数据线程--->2
main--->2
备份数据线程--->3
main--->3
备份数据线程--->4
备份数据线程--->5
main--->4
main--->5
备份数据线程--->6
main--->6
备份数据线程--->7
main--->7
备份数据线程--->8
main--->8
备份数据线程--->9
main--->9
备份数据线程--->10
备份数据线程--->11

8.定时器

8.1定时器的作用

每隔特定的时间，执行特定的程序。

比如每周都要进行银行账户的总账操作；每天都要进行数据的备份操作。

8.2实现定时器的方式

在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的。

在java中，可以采用多种方式去实现：

可以使用sleep方法，设置睡眠时间，每到这个时间点醒来，执行特定的程序。这种方式是最原始的定时器。(low)
在java中已经写好了一个定时器：java.util.Timer，可以直接拿来用。但是在实际开发中，这种方式也很少用到，因为现在有很多高级框架都是支持定时任务的。
在实际开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置就可以完成定时器的任务。

8.3 实现一个定时器

package proThread.timer;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
 * @Author: TSCCG
 * @Date: 2021/06/30 22:46
 */
public class TimerDemo01 {
    public static void main(String[] args) throws ParseException {
        //创建一个定时器对象
        Timer timer = new Timer();
        //Timer timer = new Timer(true);守护线程的方式
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTimer = sdf.parse("2021-6-30 22:56:50");
        //指定定时任务
        //timer.schedule(定时任务,第一次执行时间,间隔多久执行一次);
        timer.schedule(new LogTimerTask(),firstTimer,1000);
    }
}
//编写一个定时任务类
//假设这是一个记录日志的定时任务
class LogTimerTask extends TimerTask {

    @Override
    public void run() {
        //编写需要执行的任务就可以了
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //获取当前时间
        String strTimer = sdf.format(new Date());
        System.out.println(strTimer + "：成功完成一次备份");
    }
}

结果：

2021-07-01 10:06:51：成功完成一次备份
2021-07-01 10:06:52：成功完成一次备份
2021-07-01 10:06:53：成功完成一次备份
2021-07-01 10:06:54：成功完成一次备份
2021-07-01 10:06:55：成功完成一次备份
2021-07-01 10:06:56：成功完成一次备份
2021-07-01 10:06:57：成功完成一次备份
2021-07-01 10:06:58：成功完成一次备份

9.实现线程的第三种方式：实现Callable接口(JDK8新特性)

第三种方式：实现Callable接口

以这种方式实现的线程可以获取线程的返回值。

之前的两种方式无法获取返回值，因为run方法返回void.

代码：

package Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * @Author: TSCCG
 * @Date: 2021/07/01 10:22
 */
public class ThreadDemo13 {
    public static void main(String[] args) throws Exception {
        System.out.println("Main ---> Start");
        //第一步：创建一个"未来任务类"对象
        //参数非常重要，需要给一个Callable接口实现类对象
        FutureTask<Object> task = new FutureTask<>(new MyGetThread01());
        Thread t1 = new Thread(task);
        t1.setName("t1");
        t1.start();
        //在主线程中获取t线程的返回值
        //get方法的执行会导致当前线程阻塞
        Object ot = task.get();
        System.out.println("线程t1的执行结果：" + ot);
        //main线程如果想执行下面的语句，必须等待get方法的结束
        //而get方法的执行可能要很久，因为get方法是为了拿到t线程的执行结果
        //t线程的执行是需要时间的。
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
        System.out.println("Main ---> Over");
    }
}
class MyGetThread01 implements Callable<Object> {
    /**
     * call()方法就相当于run方法。只不过这个有返回值
     */
    @Override
    public Object call() throws Exception {
        //线程执行一个任务，执行后可能会有一个执行结果
        System.out.println("T1 ---> Start");
        int i = 0;
        for (; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
        System.out.println("T1 ---> Over");
        //自动装箱成Integer
        return i;
    }
}

结果：

Main ---> Start
T1 ---> Start
t1--->0
t1--->1
t1--->2
t1--->3
t1--->4
T1 ---> Over
线程t1的执行结果：5
main--->0
main--->1
main--->2
main--->3
main--->4
Main ---> Over

10.wait和notify方法(生产者和消费者模式)

10.1 wait和notify方法是Object类中自带的

wait和notify方法不是线程对象的方法，是Object类中自带的，java中任何一个java对象都有这两个方法。

wait和notify方法不是通过线程对象调用的。

10.2 wait和notify方法的作用

Object obj = new Object();

wait()方法：
- 让正在obj对象上活动的线程进入等待状态，并且是无限期等待，直到被唤醒为止。
- 比如说现在t1线程正在obj对象上活动，此时，对象obj调用wait方法：obj.wait();
  
  线程t1就会进入等待状态。
- obj.wait();的执行会释放obj对象的锁。
notify()方法：
- obj.notify();
- 唤醒正在obj对象上等待的线程。
- 不会释放obj对象的锁。
notifyAll()方法：
- obj.notifyAll();
- 唤醒所有在obj对象上等待的线程。

注意：

wait和notify方法建立在synchronized线程同步的基础上。

10.3 生产者和消费者模式

10.3.1生产者和消费者模式概述

创建一个仓库对象obj，

一个线程负责生产数据传入仓库中，称之为生产者，
另一个线程负责消费仓库中的数据，称之为消费者。

仓库对象是线程共享的，所以要考虑线程安全问题。

最终生产和消费必须要达到均衡状态，也就是：

生产者生产至仓库满了，就不能生产了，必须要让消费者进行消费。
消费者消费至仓库空了，就不能消费了，必须要让生产者进行生产。

为了实现这点，仓库对象obj需要调用wait和notify方法，

wait和notify方法建立在synchronized线程同步的基础上，wait方法的调用会释放线程之前占有的对象锁，而notify不会释放线程之前占有的对象锁。

10.3.2生产者和消费者模式实例1

实现一个生产者和消费者交替输出的例子：

package Thread;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: TSCCG
 * @Date: 2021/07/01 15:06
 * 生产者和消费者交替打印
 */
public class ThreadDemo14 {
    public static void main(String[] args) {
        //创建一个仓库共享对象list
        List list = new ArrayList();
        //将list传入生产者线程和消费者线程
        //生产者对象
        Producer01 t1 = new Producer01(list);
        //消费者对象
        Consumer01 t2 = new Consumer01(list);
        t1.setName("生产者线程");
        t2.setName("消费者线程");
        t1.start();
        t2.start();

    }
}
/**
 * 生产者线程
 */
class Producer01 extends Thread {
    //仓库
    private List list;
    public Producer01(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        //让生产者一直生产
        while (true) {
            //给仓库对象加锁
            synchronized (list) {
                //设定仓库中最多能存储1个元素
                //判断，如果仓库中元素的个数大于0，则让生产者线程进入等待，并释放之前占有的list对象锁
                if (list.size() > 0) {
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //程序能够执行到此说明仓库是空的，可以进行生产。
                Object obj = new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName() + "--->" + obj);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //唤醒消费者进行消费
                list.notifyAll();
                /*
                执行完上一语句后，唤醒消费者线程，
                然后生产者线程里synchronized里的同步代码块执行完毕，生产者线程释放占有的list对象锁。
                此时消费者有机会抢到list对象锁，而生产者也有可能再次抢夺到list对象锁。
                假设生产者再次抢夺到了list对象锁，但由于此时仓库里已经有了一个元素，
                通过if判断语句，生产者线程会进入等待状态，再次释放list对象锁.
                在消费者线程里也是如此，这样能够保证生产者和消费者交替打印.
                 */
            }
        }
    }
}

/**
 * 消费者线程
 */
class Consumer01 extends Thread {
    private List list;
    public Consumer01(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        //让消费者一直消费
        while (true) {
            //给仓库对象加锁
            synchronized (list) {
                //判断，如果仓库中已经没有元素了，就不能消费了，让消费者线程等待，并且释放list对象锁
                if (list.size() == 0) {
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果程序执行到此，说明仓库中存在元素，执行删除操作
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "--->" + obj);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //唤醒生产者进行生产
                list.notifyAll();
            }
        }
    }
}

结果：

生产者线程--->java.lang.Object@1bcfca5d
消费者线程--->java.lang.Object@1bcfca5d
生产者线程--->java.lang.Object@15082754
消费者线程--->java.lang.Object@15082754
生产者线程--->java.lang.Object@1137a12d
消费者线程--->java.lang.Object@1137a12d

10.3.3生产者和消费者模式实例2

t1线程和t2线程交替打印如下字段，要求使用生产者和消费者模式，t1线程打印奇数，t2线程打印偶数。

t1--->1

t2--->2

t1--->3

t2--->4

...

package Thread;

/**
 * @Author: TSCCG
 * @Date: 2021/07/01 15:06
 * t1线程和t2线程交替打印如下字段，要求使用生产者和消费者，t1线程打印奇数，t2线程打印偶数
 * t1--->1
 * t2--->2
 * t1--->3
 * t2--->4
 * ...
 */
public class ThreadDemo15 {
    public static void main(String[] args) {
        //定义一个共享仓库对象num
        Num num = new Num(1);
        //t1线程
        Producer02 t1 = new Producer02(num);
        //t2线程
        Consumer02 t2 = new Consumer02(num);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
}
class Num {
    int i;
    public Num(int i) {
        this.i = i;
    }
}

/**
 * 线程t1
 */
class Producer02 extends Thread {
    private Num num;
    public Producer02 (Num num) {
        this.num = num;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (num) {
                //判断，如果是偶数，则让t1线程进入等待状态
                if (num.i % 2 == 0) {
                    try {
                        num.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "--->" + num.i);
                num.i++;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //唤醒线程t2
                num.notifyAll();
            }
        }
    }
}

/**
 * 线程t2
 */
class Consumer02 extends Thread {
    private Num num;
    public Consumer02 (Num num) {
        this.num = num;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (num) {
                //判断，如果是奇数则让线程t2进入等待状态
                if (num.i % 2 != 0) {
                    try {
                        num.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "--->" + num.i);
                num.i++;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //唤醒t1线程
                num.notifyAll();
            }
        }
    }
}

结果：

t1--->1
t2--->2
t1--->3
t2--->4
t1--->5
t2--->6
t1--->7
t2--->8
t1--->9
t2--->10

posted @ 2021-06-27 11:45 TSCCG 阅读(54) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

TSCCG

JavaseLearn18-多线程

JavaseLearn18-多线程

1.多线程概述

1.1 什么是进程？什么是线程？

1.2进程与线程的关系

1.3多线程并发

1.3.1举个栗子：

1.3.2思考问题：

1.5分析程序存在几个线程

2.实现线程的方式

2.1第一种"_"

2.2第二种T_T

3.线程生命周期

4.线程的常用方法

4.1获取当前线程对象

4.2获取当前线程名字

4.3修改当前线程名字

4.4 sleep()方法

4.4.1 作用及用法

4.4.2 sleep()面试题

4.4.3 中断线程的休眠

4.4.4 终止线程的执行

5. 线程调度

5.1 常见的线程调度模型

5.2 java中与线程调度有关的方法

5.2.1 线程优先级

5.2.2 线程让位

5.2.3 线程合并

6.线程安全

6.1 为什么说线程安全是重点？

6.2 线程安全问题

6.2.1 银行例子

6.2.2 总结线程不安全的条件

6.2.3 有线程安全问题的变量

6.3 解决线程安全问题

6.3.1 同步编程模型和异步编程模型

6.3.2 同步代码块synchronized

6.3.3 深入理解synchronized

1.小括号里填什么？

2.使用synchronized改进代码后的执行过程：

6.3.4 synchronized的三种写法

6.3.5 synchronized面试题

面试题1：

面试题2：

面试题3：

面试题4：

6.3.6 在实际开发中应该怎么解决线程安全问题

6.4死锁

7.守护线程

7.1 什么是守护线程？

7.2 守护线程用在什么地方呢？

7.3 实现一个守护线程：

8.定时器

8.1定时器的作用

8.2实现定时器的方式

8.3 实现一个定时器

9.实现线程的第三种方式：实现Callable接口(JDK8新特性)

10.wait和notify方法(生产者和消费者模式)

10.1 wait和notify方法是Object类中自带的

10.2 wait和notify方法的作用

10.3 生产者和消费者模式

10.3.1生产者和消费者模式概述

10.3.2生产者和消费者模式实例1

10.3.3生产者和消费者模式实例2

公告

2.1第一种"^_"