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

文章目录

          • 程序、进程、线程的概念
          • 线程的三种创建方式
            • 继承Thread类
            • 实现Runnable接口
            • 实现Callable接口
          • 静态代理
          • Lambda表达式
          • 线程的状态
          • 线程的方法
          • 线程的停止
          • 线程休眠
          • 线程礼让
          • 线程强制执行(插队)
          • 线程状态
          • 线程优先级
          • 守护线程
          • 线程同步机制
          • 线程不安全的例子
            • 示例1
            • 示例2
            • 示例3
          • synchronized解决线程不安全
            • 示例1
            • 示例2
            • 示例3
          • copyOnWriteArrayList
          • 线程死锁
          • Lock锁
          • synchronized与Lock的对比
          • 线程通信
            • 管程法通信
            • 信号灯法通信
          • 线程池
          • 鸣谢

程序、进程、线程的概念

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

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

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

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

例子:

/**
 * @author [email protected]
 * @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方法正在执行");
        }
    }
}

执行结果:
Java基础学习-Java多线程(通俗易懂的多线程入门笔记)_第1张图片
总结:我们发现了001和002线程在交叉执行,当两个线程都在执行的时候其实是两个线程在并行交替执行。

实现Runnable接口

例子:

/**
 * @author [email protected]
 * @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 [email protected]
 * @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方法

  1. 实现 Callable 接口,需要返回值类型
  2. 重写 call 方法,需要抛出异常
  3. 创建目标对象
  4. 创建执行服务(线程池):ExecutorService = Executor.newFixedThreadPool(1);
  5. 提交执行:Future result1 = ser.submit(1);
  6. 获取结果:boolean r1 = result.get()
  7. 关闭服务: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);
}
线程的状态

线程的状态图:
Java基础学习-Java多线程(通俗易懂的多线程入门笔记)_第2张图片

线程的方法

Java基础学习-Java多线程(通俗易懂的多线程入门笔记)_第3张图片

线程的停止
  1. 建议线程正常停止,利用次数不建议死循环
  2. 建议使用标志位,设置一个线程停止的标志
  3. 不要使用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("线程停止了!");
            }
        }
    }
}
线程休眠
  1. sleep(时间)指定当前线程阻塞的毫秒数;
  2. sleep存在异常InterruptedException
  3. sleep时间到达后线程进入就绪状态
  4. sleep可以模拟网络延时,倒计时等。
  5. 每一个对象都有一个锁,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();
            }
        }
    }
}
线程礼让
  1. 礼让线程,让当前正在执行的线程暂停,但不阻塞
  2. 将线程从运行状态转为就绪状态
  3. 让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

同步监视器的执行过程:

  1. 第一个线程访问,锁定同步监视器,执行其中代码
  2. 第二个线程访问,发现同步监视器被锁定,无法访问
  3. 第一个线程访问完毕,解除同步监视器
  4. 第二个线程访问,发现同步监视器没有锁
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 > 同步代码块(已经进入了方法体,分配了相应资源)> 同步方法(在方法体之外)
线程通信

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

  • 假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费。

  • 如果仓库中没有产品,则将生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止。

  • 如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费,直到仓库中再次放入产品为止。
    Java基础学习-Java多线程(通俗易懂的多线程入门笔记)_第4张图片
    这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件。

  • 对于生产者,没有生产产品之前,要通知消费者等待.而生产了产品之后,又需要马上通知消费者消费

  • 对于消费者,在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费.

  • 在生产者消费者问题中,仅有synchronized是不够的

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

解决线程通信的几个方法:Java基础学习-Java多线程(通俗易懂的多线程入门笔记)_第5张图片

管程法通信

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

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

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

案例:

//测试:生产者消费者模型---》管程法
//消费者,生产者,商品,缓冲区
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:线程没有任务时最多保持多长时间后会终止
      Java基础学习-Java多线程(通俗易懂的多线程入门笔记)_第6张图片

线程池的案例:

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

你可能感兴趣的:(多线程,狂神说,java,开发语言,后端,多线程)