Java基础学习-Java多线程(通俗易懂的多线程入门笔记)

HCAN学Java

已于 2022-01-20 15:29:03 修改

阅读量358

点赞数

分类专栏：多线程狂神说文章标签： java 开发语言后端多线程

于 2022-01-20 15:25:09 首次发布

本文链接：https://blog.csdn.net/qq_33631756/article/details/122602331

版权

狂神说同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

多线程

1 篇文章 0 订阅

订阅专栏

程序、进程、线程的概念

程序：程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

进程：进程是执行程序的一个过程，它是一个动态的概念。是系统资源分配的单位。

线程：一个进程中包含多个线程，一个进程中至少有一个线程。线程是CPU调度和执行的单位。

线程就是独立的执行路径
在程序运行时,即使没有自己创建线程，后台也会有多个线程，比如主线程，GC线程
main()称之为主线程,为系统的入口，用于执行整个程序
在一个进程中,如果开辟了多个线程,线程的运行是由调度器安排调度的，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
线程会带来额外的开销，如CPU调度时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程的三种创建方式

继承Thread类

例子：

/**
 * @author can.he@hand-china.com
 * @description 继承Thread来创建线程
 * @date 2022/1/5 11:56
 */
public class createThread01 {
    public static void main(String[] args) {
        // 实例化一个线程对象并调用start()方法执行
        ThreadDemo01 threadDemo01 = new ThreadDemo01();
        threadDemo01.start();
    }
}

class ThreadDemo01 extends Thread {
    // 线程创建方式一：继承Thread类
    // 重写run()方法
    @Override
    public void run() {
        System.out.println("线程run方法正在执行");
    }
}

多个线程启动测试：

public class createThread01 {
    public static void main(String[] args) {
        // 实例化一个线程对象并调用start()方法执行
        ThreadDemo01 threadDemo01 = new ThreadDemo01();
        ThreadDemo02 threadDemo02 = new ThreadDemo02();
        threadDemo01.start();
        threadDemo02.start();


    }
}

class ThreadDemo01 extends Thread {
    // 线程创建方式一：继承Thread类
    // 重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程001run方法正在执行");
        }
    }
}

class ThreadDemo02 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程002run方法正在执行");
        }
    }
}

执行结果：
在这里插入图片描述
总结：我们发现了001和002线程在交叉执行，当两个线程都在执行的时候其实是两个线程在并行交替执行。

实现Runnable接口

例子：

/**
 * @author can.he@hand-china.com
 * @description 线程创建方式二：实现Runnable接口来创建线程
 * @date 2022/1/5 15:36
 */
public class createThread02 {
    public static void main(String[] args) {
        // 实例化一个Runnable线程对象
        TestRunnable01 testRunnable01 = new TestRunnable01();
        // 实例化一个线程Thread，将Runnable对象放进线程Thread去执行
        Thread thread = new Thread(testRunnable01);
        // 调用方法执行线程
        thread.start();
    }
}

class TestRunnable01 implements Runnable {
    // 线程创建方式二：实现Runnable接口
    // 重写run()方法

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程001run方法正在执行");
        }
    }
}

以上两种方式的比较：

继承 Thread 类

子类继承 Thread 类具备多线程能力
启动线程：子类对象 .start()
不建议使用：避免 OOP 单继承局限性
实现 Runnable 接口

实现接口 Runnable

具有多线程能力
启动线程：传入目标对象 + Thread对象.start()
推荐使用：避免单继承局限性，方便同一个对象被多个线程使用。

避免单继承局限性，方便同一个对象被多个线程

同一个对象被多个线程使用测试例子：

/**
 * @author can.he@hand-china.com
 * @description 多个线程同时操作同一个对象,买火车票例子
 * @date 2022/1/5 15:51
 */
public class createThread03 {
    public static void main(String[] args) {
        TestThread01 threadThree = new TestThread01();
        new Thread(threadThree,"小明").start();
        new Thread(threadThree,"老师").start();
        new Thread(threadThree,"老黄牛").start();
    }
}

class TestThread01 implements Runnable {

    private Integer ticketNums = 10;

    @Override
    public void run() {
        while(true){
            if (ticketNums<=0){
                System.out.println(Thread.currentThread().getName()+", 没有买到票");
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"——>拿到了第"+ticketNums--+"张票");
        }
    }
}

输出结果：

小明——>拿到了第10张票
老黄牛——>拿到了第10张票
老师——>拿到了第10张票
小明——>拿到了第9张票
老师——>拿到了第8张票
老黄牛——>拿到了第7张票
小明——>拿到了第5张票
老师——>拿到了第6张票
老黄牛——>拿到了第6张票
老师——>拿到了第2张票
老黄牛——>拿到了第4张票
小明——>拿到了第3张票
老师——>拿到了第1张票
小明——>拿到了第1张票
老黄牛——>拿到了第0张票
老黄牛, 没有买到票
小明, 没有买到票
老师, 没有买到票

发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱。

实现Callable接口

实现Callable接口，重写call方法

实现 Callable 接口，需要返回值类型
重写 call 方法，需要抛出异常
创建目标对象
创建执行服务(线程池)：ExecutorService = Executor.newFixedThreadPool(1);
提交执行：Future result1 = ser.submit(1);
获取结果：boolean r1 = result.get()
关闭服务：ser.shutdownNow():

图片下载测试例子：

public class TestCallable implements Callable<Boolean> {

    private String url;
    private String name;

    public TestCallable(String url, String name) {
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() throws Exception {
        // 图片下载
        downloader(url, name);
        return true;
    }

    // 下载图片的方法
    public void downloader(String url, String name) {
        System.out.println("正在下载图片url="+url+", name="+name);
        System.out.println("下载图片"+name+"完成");
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable testThread1 = new TestCallable("http://url1", "1.png");
        TestCallable testThread2 = new TestCallable("http://url2", "2.png");
        TestCallable testThread3 = new TestCallable("http://url3", "3.png");
        TestCallable testThread4 = new TestCallable("http://url4", "4.png");
        //创建执行服务(线程池):
        ExecutorService service = Executors.newFixedThreadPool(4);
        //提交执行:
        Future<Boolean> r1 = service.submit(testThread1);
        Future<Boolean> r2 = service.submit(testThread2);
        Future<Boolean> r3 = service.submit(testThread3);
        Future<Boolean> r4 = service.submit(testThread4);
        // 获取结果:
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        boolean rs4 = r4.get();
        // 返回结果打印
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        System.out.println(rs4);
        //关闭服务:
        service.shutdownNow();
    }
}

输出结果：

正在下载图片url=http://url2, name=2.png
下载图片2.png完成
正在下载图片url=http://url3, name=3.png
下载图片3.png完成
正在下载图片url=http://url1, name=1.png
下载图片1.png完成
正在下载图片url=http://url4, name=4.png
下载图片4.png完成
true
true
true
true

静态代理

一个结婚代理场景：

你：一个结婚的人，真实对象
婚庆公司：代理你，帮你处理结婚的事
结婚：结婚的具体实现，实现结婚接口即可。

根据上面说到的3个角色创建分别创建以下代码

1、定义一个结婚接口

public interface MarryService {
    // 定义一个结婚接口

    void doMarry();
}

2、定义一个真实的结婚对象（人），实现结婚接口

public class Preson implements MarryService{
    private String name;

    public Preson(String name) {
        this.name = name;
    }

    @Override
    public void doMarry() {
        System.out.println(this.name + "-->正在开心的结婚");
    }
}

3、定义一个婚庆公司，实现一个结婚接口，传入一个具体的结婚对象（人），做一些结婚对象无法做的事情。

public class MarryCompany implements MarryService{

    private Preson preson;

    public MarryCompany(Preson preson) {
        this.preson = preson;
    }

    @Override
    public void doMarry() {
        before();
        this.preson.doMarry();
        after();
    }

    private void before () {
        System.out.println("准备结婚了，开始布置婚礼现场");
    }
    private void after () {
        System.out.println("准备完毕，找新郎结尾款");
    }
}

4、测试代理结婚场景

public class TestStaticProxy {

    public static void main(String[] args) {
        // 定义一个结婚的人叫张三
        Preson preson = new Preson("张三");
        // 将张三交给婚庆公司
        MarryCompany marryCompany = new MarryCompany(preson);
        // 婚庆公司安排结婚
        marryCompany.doMarry();
    }
}
// 输出
准备结婚了，开始布置婚礼现场
张三-->正在开心的结婚
准备完毕，找新郎结尾款

5、李四看到张三结婚了，觉得他家婚礼办得不错，觉得他结婚也去找那一家婚庆公司

public class TestStaticProxy {
    public static void main(String[] args) {
        Preson preson = new Preson("张三");
        MarryCompany marryCompany = new MarryCompany(preson);
        marryCompany.doMarry();

        Preson preson2 = new Preson("李四");
        MarryCompany marryCompany2 = new MarryCompany(preson2);
        marryCompany2.doMarry();
    }
}
// 输出
准备结婚了，开始布置婚礼现场
张三-->正在开心的结婚
准备完毕，找新郎结尾款
准备结婚了，开始布置婚礼现场
李四-->正在开心的结婚
准备完毕，找新郎结尾款

静态代理模式总结：

真实对象和代理对象都要实现同一个接口
代理对象要代理真实角色
代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事情

对比Thread：

public class TestStaticProxy {

    public static void main(String[] args) {
        // 定义一个结婚的人叫张三
        Preson preson = new Preson("张三");
        // 将张三交给婚庆公司
        MarryCompany marryCompany = new MarryCompany(preson);
        // 婚庆公司安排结婚
        marryCompany.doMarry();
        
        // ****对比Thread****//
        
        // 实例化一个Runnable线程对象<==>定义一个结婚的人叫张三
        TestRunnable01 testRunnable01 = new TestRunnable01();
        // 实例化一个线程Thread，将Runnable对象放进线程Thread去执行<==>将张三交给婚庆公司
        Thread thread = new Thread(testRunnable01);
        // 调用方法执行线程<==>婚庆公司安排结婚
        thread.start();
    }
}

总结：

Thread线程执行就是使用了静态代理模式
Thread类实现了一个Runnable接口
定义的Runnable线程对象也是实现了一个Runnable接口

Lambda表达式

Lambda 表达式属于函数式编程的概念
避免匿名内部类定义过多
去掉了一堆没有意义的代码,只留下核心逻辑
理解 Functional Interface（函数式接口）是学习 Java 8 Lambda 表达式的关键所在
函数式接口是只包含一个方法的接口。比如Java标准库中的java.lang.Runnable和 java.util.Comparator都是典型的函数式接口
Java中的lambda无法单独出现，它需要一个函数式接口来盛放，lambda表达式方法体其实就是函数接口的实现

函数式接口的定义：

任何接口，如果只包含唯一的一个方法，那么它就是函数式接口
```
public interface Runnable{
    public abstract void run();
}
```

对于函数式接口，可以通过 Lambda 表达式来创建该接口的对象

//1.定义一个函数式接口
interface ILike{
    void like();
}
//6.用lambda简化，-->函数式接口
like = ()->{
	System.out.println("i like lambda5");
};

lamdba表达式语法，包含三部分：

一个括号内用逗号分隔的形式参数，参数是函数式接口里面方法的参数
一个箭头符号：->
方法体，可以是表达式和代码块

(parameters) -> expression 或者 (parameters) -> { statements; }

lamdba表达式的简化过程：

/**
 * @description Lamdba表达式的简化演变过程
 * @date 2022/1/6 9:57
 */
public class TestLamdba {
    // 3、定义静态内部类
    static class ILikeImpl2 implements ILike {
        @Override
        public void lambda() {
            System.out.println("我喜欢lamdba02");
        }
    }

    public static void main(String[] args) {
        // 实现类输出
        ILike iLike = new ILikeImpl();
        iLike.lambda();

        // 静态内部类输出
        iLike = new ILikeImpl2();
        iLike.lambda();

        // 4、定义一个局部内部类
        class ILikeImpl3 implements ILike {
            @Override
            public void lambda() {
                System.out.println("我喜欢lamdba03");
            }
        }

        // 局部内部类输出
        iLike = new ILikeImpl3();
        iLike.lambda();

        // 5、定义一个匿名内部类
        iLike = new ILike() {
            @Override
            public void lambda() {
                System.out.println("我喜欢lamdba04");
            }
        };
        // 匿名内部类输出
        iLike.lambda();

        // 6、lamdba简化匿名内部类
        iLike = () -> {
            System.out.println("我喜欢lamdba05");
        };
        iLike.lambda();

        // 7、lamdba表达式只有一行代码的最终简化
        iLike = () -> System.out.println("我喜欢lamdba06");
        iLike.lambda();
    }
}

// 1、定义一个函数式接口
@FunctionalInterface
interface ILike {
    void lambda ();
}

// 2、实现类
class ILikeImpl implements ILike {
    @Override
    public void lambda() {
        System.out.println("我喜欢lamdba01");
    }
}
// 输出
我喜欢lamdba01
我喜欢lamdba02
我喜欢lamdba03
我喜欢lamdba04
我喜欢lamdba05
我喜欢lamdba06

带参数的lamdba表达式简化：

public class TestLambda {

    public static void main(String[] args) {
        ILove love = null;
        /*
        ILove love = (String name) -> {
            System.out.println("I love you, " + name + "!");
        };
        love.love("王麻子");

        //简化Lambda表达式,1.简化类型
        love = (name) -> {
            System.out.println("I love you, " + name + "!");
        };

        //简化Lambda表达式,2.去掉括号
        love = name -> {
            System.out.println("I love you, " + name + "!");
        };
		*/

        //3. 简化花括号
        love = name -> System.out.println("I love you, " + name + "!");
        love.love("521");

        //总结:
        //lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
        //前提是接口为函数式接口
        //多个参数也可以去掉参数类型，要去掉就都去掉,必须加上括号，
    }
}

interface ILove {
    void love(String name);
}

线程的状态

线程的状态图：
在这里插入图片描述

线程的方法

在这里插入图片描述

线程的停止

建议线程正常停止，利用次数不建议死循环
建议使用标志位，设置一个线程停止的标志
不要使用stop或者destroy等过时的方法或者JDK不建议使用的方法

测试代码

// 测试线程停止
public class ThreadStop implements Runnable{
    // 标志位
    private Boolean flag = true;

    @Override
    public void run() {
        int i=0;
        while (flag){
            System.out.println("run.....Thread"+(i++));
        }
    }

    public void stop () {
        this.flag = false;
    }

    public static void main(String[] args) {
        // 启动线程
        ThreadStop testStop = new ThreadStop();
        new Thread(testStop).start();

        // 循环100次在900的时候停止线程
        for (int i = 0; i <1000 ; i++) {
            System.out.println("main"+i);
            if (i==900){
                testStop.stop();
                System.out.println("线程停止了！");
            }
        }
    }
}

线程休眠

sleep（时间）指定当前线程阻塞的毫秒数；
sleep存在异常InterruptedException
sleep时间到达后线程进入就绪状态
sleep可以模拟网络延时，倒计时等。
每一个对象都有一个锁，sleep不会释放锁

public class TestSleep1 {
    public static void main(String[] args) {
    tenDown();
    //打印当前系统时间
        Date startTime=new Date(System.currentTimeMillis());//获取当前系统时间
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime=new Date(System.currentTimeMillis());//更新时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //模拟倒计时
    public static void tenDown(){
        int num=10;
        while (true){
            try {
                Thread.sleep(1000);
                if (num<=0){
                    break;
                }else{
                    System.out.println("倒计时！！！"+num--+"秒");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程礼让

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让cpu重新调度，礼让不一定成功！看CPU心情

// 测试线程礼让
public class TestYield implements Runnable {
    public static void main(String[] args) {
        TestYield yield=new TestYield();
        new Thread(yield,"a").start();
        new Thread(yield,"b").start();
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

线程强制执行(插队)

join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞

//测试join方法，想象为插队
public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("vip线程来了" + i);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        //线程启动
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        
        //主线程
        for (int i = 0; i < 500; i++) {
            if (i == 200) {
                thread.join();//插队
            }
            System.out.println("main线程" + i);
        }
    }
}

线程状态

Thread.State，线程状态有哪些？

new 尚未启动的线程处于此状态
Runnable 在java虚拟机中执行的线程处于此状态
Blocked 被阻塞等待监视器锁定的线程处于此状态。
Waiting 正在等待另一个线程执行特定动作的线程处于此状态。
Timed Waiting 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
Terminated 已退出的线程处于此状态。

一个线程可以给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态

示例代码

public class TestThreadState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("//");
        });

        // 线程新建，状态 NEW
        System.out.println(thread.getState());
        // 启动线程，状态 RUNNABLE
        thread.start();
        System.out.println(thread.getState());
        // 运行状态，只要线程不终止就输入线程状态 TIMED_WAITING
        while (thread.getState()!= Thread.State.TERMINATED){
            Thread.sleep(100);
            System.out.println(thread.getState());
        }
    }
}
// 输出
NEW
RUNNABLE
TIMED_WAITING
......
TIMED_WAITING
//
TERMINATED

线程优先级

java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

线程的优先级用数字表示，范围从1~10。先设置优先级，再start线程！！！

使用getPriority().setPriority(int xxx) 改变或获取优先级，设置优先级后并不是一定会按照优先级执行，而是大概率会按照优先级执行

代码：

public class TestPriority {
    public static void main(String[] args) {
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);
        //先设置线程优先级
        t1.setPriority(1);
        t1.start();
        t2.setPriority(3);
        t2.start();
        t3.setPriority(6);
        t3.start();
        t4.setPriority(Thread.MAX_PRIORITY);//  优先级=10
        t4.start();
        t5.setPriority(Thread.MIN_PRIORITY);// 优先级=1
        t6.setPriority(9);
        t6.start();

        System.out.println("main");
    }
}
class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"---线程被执行了！---"+Thread.currentThread().getPriority());
    }
}
// 输出
main
Thread-3---线程被执行了！---10
Thread-5---线程被执行了！---9
Thread-2---线程被执行了！---6
Thread-1---线程被执行了！---3
Thread-0---线程被执行了！---1

守护线程

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
如，后台记录操作日志，监控内存，垃圾回收等待。。。

测试守护线程代码

public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you=new You();
        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认为flase 为用户线程，  true为守护线程
        thread.start();
        new Thread(you).start();
    }
}
class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝守护着你-------");
        }
    }
}
class You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <36500 ; i++) {
            System.out.println("开心着活着每一天------");
        }
        System.out.println("----goodbye!Beautiful World!!!------");
    }
}

线程同步机制

线程同步：

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可

使用锁会出现的问题：

一个线程持有锁会导致其它所有需要此锁的线程挂起；
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。

线程不安全的例子

示例1

不安全的买票

//线程不安全，买票重复
public class UnsafeBuyTicket {

    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket, "我").start();
        new Thread(buyTicket, "你").start();
        new Thread(buyTicket, "他").start();
    }
}

class BuyTicket implements Runnable {
    //票
    private int ticket = 10;
    //外部停止标志
    boolean flag = true;
    
    @Override
    public void run() {
        //买票
        while (flag) {
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void buy() throws InterruptedException {
        if (ticket <= 0) {
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName() + "买到" + ticket--);
    }
}
// 输出
他买到10
你买到8
我买到9
你买到7
他买到7
我买到7
我买到6
他买到6
你买到5
他买到4
你买到3
我买到4
他买到2
你买到0
我买到1

示例2

不安全的取钱

//取钱线程不安全
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100, "结婚基金");
        Drawing you = new Drawing(account, 50, "你");
        Drawing girlFriend = new Drawing(account, 100, "girlFriend");

        you.start();
        girlFriend.start();
    }
}
class Account {
    //账户名称
    String name;
    //账户余额
    int money;

    public Account(int money, String name) {
        this.name = name;
        this.money = money;
    }
}


class Drawing extends Thread {
    Account account;//银行账户
    int drawingMoney;//取了多少钱
    int nowMoney;//剩余多少钱
    public Drawing(Account account, int drawingMoney, String name) {
        this.account = account;
        this.drawingMoney = drawingMoney;
        super.setName(name);
    }
    //取钱
    @Override
    public void run() {
        if (account.money - drawingMoney < 0) {
            System.out.println("卡内余额不足，取不了！");
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 卡内余额 = 余额–你取的钱
        account.money = account.money - drawingMoney;
        //你手里的钱
        nowMoney = nowMoney + drawingMoney;
        System.out.println(account.name + "余额为:" + account.money);
        //Thread.currentThread().getName() == this.getName()
        System.out.println(this.getName() + "手里的钱" + nowMoney);
    }
}
// 输出
结婚基金余额为:-50
你手里的钱50
结婚基金余额为:-50
girlFriend手里的钱100

示例3

ArrayList线程不安全的，我没连续添加1000个数据发现最后只存在996个，有的添加在同一个位置被覆盖了

public class UnsafeList {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        for (int i = 0; i <1000 ; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(list.size());
    }
}
// 输出
996

以上三个例子都是线程不安全的场景，那么我可以使用线程的同步机制synchronized来修改上面的测试代码

synchronized解决线程不安全

示例1

修改买票代码：在29行加上synchronized关键子修饰方法，将方法锁住，每次只有一个线程执行该方法

public class UnsafeBuyTicket {

    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket, "我").start();
        new Thread(buyTicket, "你").start();
        new Thread(buyTicket, "他").start();
    }
}

class BuyTicket implements Runnable {
    //票
    private int ticket = 10;
    //外部停止标志
    boolean flag = true;
    
    @Override
    public void run() {
        //买票
        while (flag) {
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    // 这里的锁住的是方法，其实是把方法所在的类给锁住了BuyTicket给锁住了和传this参数效果一样
    public synchronized void buy() throws InterruptedException {
        if (ticket <= 0) {
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(200);
        System.out.println(Thread.currentThread().getName() + "买到" + ticket--);
    }
}
// 输出
他买到10
他买到9
他买到8
你买到7
你买到6
我买到5
我买到4
我买到3
我买到2
我买到1

示例2

修改取钱代码：锁定代码37行添加synchronized代码块

public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100, "结婚基金");
        Drawing you = new Drawing(account, 50, "你");
        Drawing girlFriend = new Drawing(account, 100, "girlFriend");

        you.start();
        girlFriend.start();
    }
}
class Account {
    //账户名称
    String name;
    //账户余额
    int money;

    public Account(int money, String name) {
        this.name = name;
        this.money = money;
    }
}


class Drawing extends Thread {
    Account account;//银行账户
    int drawingMoney;//取了多少钱
    int nowMoney;//剩余多少钱
    public Drawing(Account account, int drawingMoney, String name) {
        this.account = account;
        this.drawingMoney = drawingMoney;
        super.setName(name);
    }
    //取钱
    @Override
    public void run() {
        synchronized (account) {
            if (account.money - drawingMoney < 0) {
                System.out.println("卡内余额不足，取不了！");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 卡内余额 = 余额–你取的钱
            account.money = account.money - drawingMoney;
            //你手里的钱
            nowMoney = nowMoney + drawingMoney;
            System.out.println(account.name + "余额为:" + account.money);
            //Thread.currentThread().getName() == this.getName()
            System.out.println(this.getName() + "手里的钱" + nowMoney);
        }
    }
}
// 输出
结婚基金余额为:50
你手里的钱50
卡内余额不足，取不了！

在锁定取钱代码的时候需要注意，不能再public void run()方法这里进锁定，比如：public synchronized void run()。这里默认锁定的是Drawing类(银行)，我们应该对银行里面的账户Account进行锁定。

示例3

锁定集合添加元素代码

public class UnsafeList {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        for (int i = 0; i <1000 ; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(list.size());
    }
}
// 输出
1000

总结：在使用synchronized修饰代码或方法的时候，默认和synchronized (this) 是一样的，都是默认对当前代码和方法所在的类进行锁定。如果需要对具体的某一个类对象进行锁定，需要使用synchronized代码块(同步代码块)对需要加锁的代码加锁并传入锁定对象。

同步代码块：

Synchronized(Obj){}

Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this,就是这个对象本身，或者是class

同步监视器的执行过程：

第一个线程访问，锁定同步监视器，执行其中代码
第二个线程访问，发现同步监视器被锁定，无法访问
第一个线程访问完毕，解除同步监视器
第二个线程访问，发现同步监视器没有锁

copyOnWriteArrayList

copyOnWriteArrayList是一个线程安全的集合，包路径在java.util.concurrent.CopyOnWriteArrayList

public class safeList {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> copyOnWriteArrayList = new CopyOnWriteArrayList();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                copyOnWriteArrayList.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(copyOnWriteArrayList.size());
    }
}
// 输出
1000

线程死锁

在线程中多个线程同时操作多个资源会出现死锁的情况

测试死锁代码：

public class DeadLock {
    public static void main(String[] args) {
        Makeup makeup1 = new Makeup(0, "小红");
        Makeup makeup2 = new Makeup(1, "小白");
        makeup1.start();
        makeup2.start();
    }
}
/**
 * 口红
 */
class Lipstick {

}

/**
 * 镜子
 */
class Mirror {

}
class Makeup extends Thread {
    /**
     * 需要的资源只有一份,用static来保证
     * 因为有static 所以两个线程拿到的才是同一个口红和镜子
     */
    static Lipstick lipstick = new Lipstick();
    static Mirror Mirror = new Mirror();
    /**
     * 选择
     */
    int choice;
    /**
     * 使用
     */
    String girlName;

    public Makeup(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 化妆,互相持有对方的锁,就是需要拿到对方的资源.
     */
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            //获得口红的锁
            synchronized (lipstick) {
                System.out.println(this.girlName + "获得了口红的锁");
                Thread.sleep(1000);
                synchronized (Mirror) {
                    System.out.println(this.girlName + "获得了镜子的锁");
                }
            }
        } else {
            synchronized (Mirror) {
                System.out.println(this.girlName + "获得了镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick) {
                    System.out.println(this.girlName + "获得了口红的锁");
                }
            }
        }
    }
}
// 输出
小红获得了口红的锁
小白获得了镜子的锁

以上例子化妆操纵都在等待对方释放锁，而导致了死锁。要解决这个问题我们只需要将 private void makeup()做一下改动

改动代码：

private void makeup() throws InterruptedException {
    if (choice == 0) {
        //获得口红的锁
        synchronized (lipstick) {
            System.out.println(this.girlName + "获得了口红的锁");
            Thread.sleep(1000);
        }
        synchronized (Mirror) {
            System.out.println(this.girlName + "获得了镜子的锁");
        }
    } else {
        synchronized (Mirror) {
            System.out.println(this.girlName + "获得了镜子的锁");
            Thread.sleep(2000);
        }
        synchronized (lipstick) {
            System.out.println(this.girlName + "获得了口红的锁");
        }
    }
}

// 输出
小红获得了口红的锁
小白获得了镜子的锁
小白获得了口红的锁
小红获得了镜子的锁

产生死锁的四个必要条件:

互斥条件:一个资源每次只能被一个进程使用
请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放.
不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺.
循环等待条件:若干进程自检形成一种头尾相接的循环等待资源关系

注意: 这四个必要条件只要破解其中一个或者多个条件就可以破解死锁

Lock锁

JDK5.0开始，java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

示例：

public class TestLock {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(ticket).start();
        new Thread(ticket).start();
        new Thread(ticket).start();
    }
}
class Ticket extends Thread{
    private int ticketNums=10;
    //定义lock锁
    private final ReentrantLock lock=new ReentrantLock();
    
    @Override
    public void run() {
        while (true){
            try {
                lock.lock();//加锁
                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                } else {
                    break;
                }
            }finally {
                lock.unlock();//解锁
            }
        }
    }
}

synchronized与Lock的对比

Lock是显式锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
Lock只有代码块加锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
优先使用顺序：
Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）

线程通信

应用场景：生产者和消费者问题

假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。
如果仓库中没有产品，则将生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。
如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费，直到仓库中再次放入产品为止。

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。
对于生产者，没有生产产品之前，要通知消费者等待.而生产了产品之后，又需要马上通知消费者消费
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费.
在生产者消费者问题中，仅有synchronized是不够的

**synchronized ：**可阻止并发更新同一个共享资源，实现了同步，不能用来实现不同线程之间的消息传递（通信）

解决线程通信的几个方法：在这里插入图片描述

管程法通信

并发写作模型"“生产者/消费者模式”"–>管程法

生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

案例：

//测试：生产者消费者模型---》管程法
//消费者，生产者，商品，缓冲区
public class TestPC {
    public static void main(String[] args) {
        SyncContainer syncContainer = new SyncContainer();
        new Customer(syncContainer).start();
        new Productor(syncContainer).start();
    }
}


//消费者
class Customer extends Thread {

    //创建缓冲区
    private SyncContainer syncContainer;

    public Customer(SyncContainer syncContainer) {
        this.syncContainer = syncContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            Product pop = syncContainer.pop();
            System.out.println("消费了第" + pop.getId() + "号产品");
        }
    }
}

//生产者
class Productor extends Thread {
    //创建新的缓冲区
    private SyncContainer syncContainer;

    public Productor(SyncContainer syncContainer) {
        this.syncContainer = syncContainer;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了" + i + "只鸡！");
            syncContainer.push(new Product[i]);
        }
    }
}

//商品
class Product {
    int id;//产品编号
    public Product(int id) {
        this.id = id;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
}

//缓冲区
class SyncContainer {
    //定义容器大小
    Product[] products = new Product[10];
    //容器计数器
    int count = 0;
    //生产者放入产品
    public synchronized void push(Product[] product) {
        //如果容器满了，就等待消费者消费
        if (count == product.length) {
            //通知消费者消费，生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 如果没有满，我们就需要丢入产品
        products = product;
        count++;
        //通知消费者消费
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Product pop() {
        if (count == 0) {
            //通知生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Product product = products[count];

        //通知生产者消费
        this.notifyAll();
        return product;
    }
}

注意：上面的管程法案例只适用于只有一个生产者和消费者的情况，如果出现多个生成者或者多个消费者会出现下标越界的问题。

解释：

// 解释1
//对于数组下标越界问题的解释：
//1、狂神的这个例子只适用于一个生产者一个消费者的情况，因为消费者wait()释放对象锁权限让出CPU只会是那唯一的生产者重新拿到锁权限进行生产，这样的话不消费就生产，不生产就消费，是不会出现下标越界的，而如果不止一个消费者就会有下标越界的问题，原因如2；
//2、首先要说明，wait()表示持有对象锁的线程准备释放对象锁权限和让出 cpu 资源并进入等待状态。如果有多个消费者，比如X1，X2，X3，假如此时X1，X2，X3都处于wait状态，这时容量为0了生产者拿到锁，生产者生产了1个资源让出锁，X1拿到锁消费完之后容量又刚好为0，然后X1释放锁notifyAll通知JVM去唤醒所有竞争Container对象锁的线程，如果这个锁被X2拿到，那么就会导致0--出现数组下标越界的问题，解决方案暂时只想到把消费的if(index <=0)换成while就是让消费者线程被唤醒的时候不要立刻执行下面的代码，而是再去判断当前容量。
 while (index <= 0) {
     try {
         this.wait();
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 }
// 解释2
// 在多线程中要测试某个条件的变化时（尤其是用于线程通信的条件判断）不要选择if，而是选择while去判断。因为notify唤醒沉睡的线程后，线程会接着上次的执行继续往下执行（需要注意的是，执行wait()的线程被notify唤醒的时候，只是让while循环继续往下走，如果用if的话，继续往下走意味着跳出if语句块），所以必须使用while循环阻塞。在本例中，如果管道中有一只鸡，那么第一个消费者被唤醒去消费，消费了一只鸡之后，释放消费的锁，因为唤醒使用的是notifyAll，所以是唤醒所有等待的线程再去由CPU决定把锁给谁，如果此时不是生产者拿到了锁而是第二个消费者拿到锁，那么使用if的话则不会再做循环判断，会继续消费，从而造成数组下标越界。

信号灯法通信

案例：

public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者-->演员
class Player extends Thread {
    TV tv;

    public Player(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                this.tv.play("快乐大本营播放中");
            } else {
                this.tv.play("抖音播放中");
            }
        }
    }
}

//消费者-->观众
class Watcher extends Thread {
    TV tv;

    public Watcher(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//节目
class TV {
    //演员表演，观众等待 T
    //观众观看，演员等待 F

    String voice; //表演的节目
    boolean flag = true;

    //表演
    public synchronized void play(String voice) {

        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了：" + voice);
        //通知观众观看
        this.notify();//通知唤醒
        this.voice = voice;
        this.flag = !this.flag;
    }

    //观看
    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了：" + voice);
        //通知演员表演
        this.notify();
        this.flag = !this.flag;
    }

线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

优点：

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

线程池的案例：

public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        ExecutorService service= Executors.newFixedThreadPool(10);
        //newFixedThreadPool 参数为：线程池大小
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //2.关闭连接
        service.shutdown();
    }
}
class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

鸣谢

本博客为狂神说java多线程学习笔记
学习地址：https://www.bilibili.com/video/BV1V4411p7EF

HCAN学Java

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础学习-Java多线程(通俗易懂的多线程入门笔记)

程序、进程、线程的概念程序：程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。进程：进程是执行程序的一个过程，它是一个动态的概念。是系统资源分配的单位。线程：一个进程中包含多个线程，一个进程中至少有一个线程。线程是CPU调度和执行的单位。线程就是独立的执行路径在程序运行时,即使没有自己创建线程，后台也会有多个线程，比如主线程，GC线程main()称之为主线程,为系统的入口，用于执行整个程序在一个进程中,如果开辟了多个线程,线程的运行是由调度器安排调度的，调度器是与操作系
复制链接

扫一扫