[JUC学习笔记二] 线程的生命周期、线程的同步、线程的同步问题、Lock锁、线程的通信

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量125 收藏
点赞数 1
分类专栏： Java学习笔记 文章标签： java 多线程 编程语言 juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37109317/article/details/109952488
版权

根据尚硅谷的视频做的JUC学习笔记

目录

一、线程的生命周期

在这里插入图片描述

一个完整的生命周期通常要经历如下的五种状态：

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

二、线程的同步

​ 线程同步的提出主要是为了解决线程的安全问题。例如，当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误；而解决办法就是，对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

同步机制

在Java中，我们通过同步机制，来解决线程的安全问题。

方式一：同步代码块

synchronized(同步监视器){
	需要被同步的代码
}

说明：

1.操作共享数据的代码，即为需要被同步的代码。

2.共享数据：多个线程共同操作的变量。比如窗口卖票案例中的ticket就是共享数据。

3.同步监视器：俗称“锁”。任何一个类的对象，都可以充当锁。要求：多个线程必须要共用同一把锁。

补充：1.在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

​ 2.在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

class Window2 implements Runnable {
    private static int ticket = 100;
    private Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "张票！");
                    ticket--;
                } else
                    break;
            }
        }
    }
}
public class ThreadDemo3 {
    public static void main(String[] args) {
        Window2 w = new Window2();

        Thread w1 = new Thread(w);
        Thread w2 = new Thread(w);
        Thread w3 = new Thread(w);
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }
}

方式二：同步方法

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

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

//使用同步方法解决实现Runnable接口的线程安全问题
class Window3 implements Runnable {
    private static int ticket = 100;
    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    //定义同步方法
    private synchronized void show() {//同步监视器：this
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖出了第 " + ticket + " 张票！");
            ticket--;
        }
    }
}
public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread w1 = new Thread(w);
        Thread w2 = new Thread(w);
        Thread w3 = new Thread(w);
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }
}

使用同步方法解决继承Thread类的方式中的线程安全问题

//使用同步方法解决继承Thread类的方式中的线程安全问题
class Window4 extends Thread {
    private static int ticket = 100;
    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    //private synchronized void show() {    这种方式是错误的
    private static synchronized void show() {   //同步监视器：Window4.class
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖出了第 " + ticket + " 张票！");
            ticket--;
        }
    }
}
public class WindowTest4 {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();
        w1.setName("窗口 1 ");
        w2.setName("窗口 2 ");
        w3.setName("窗口 3 ");
        w1.start();
        w2.start();
        w3.start();
    }
}

关于同步方法的总结：

  • 1.同步方法仍然涉及到同步监视器，只是不需要我们显式地声明。
  • 2.非静态的同步方法，同步监视器是this。静态的同步方法，同步监视器是当前类的本身。

同步的方式，解决了现成的安全问题是好处。但是，操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低，这即是同步的局限性。

单例设计模式之懒汉式(线程安全)

使用同步机制将单例模式中的懒汉式改写为线程安全的

class Bank {
    private Bank() {
    }
    private static Bank instance = null;
    
    //public static synchronized Bank getInstance() {
    public static Bank getInstance() {
        //方式一：效率稍差
        /*synchronized (Bank.class) {
            if (instance == null)
                instance = new Bank();
            return instance;
        }*/
        //方式二：效率稍高
        if (instance == null) {
            synchronized (Bank.class) {
                if (instance == null)
                    instance = new Bank();
                return instance;
            }
        }
        return instance;
    }
}

三、线程的死锁问题

死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

解决方法：专门的算法、原则；尽量减少同步资源的定义；尽量避免嵌套同步。

线程死锁：

//演示线程死锁问题
public class ThreadTest4 {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer();
        StringBuffer sb2 = new StringBuffer();

        new Thread(){
            @Override
            public void run() {
                synchronized (sb1){
                    sb1.append("a");
                    sb2.append("1");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (sb2){
                        sb1.append("b");
                        sb2.append("2");
                        System.out.println(sb1);
                        System.out.println(sb2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (sb2){
                    sb1.append("c");
                    sb2.append("3");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (sb1){
                        sb1.append("d");
                        sb2.append("4");
                        System.out.println(sb1);
                        System.out.println(sb2);
                    }
                }
            }
        }).start();
    }
}

出现死锁：
在这里插入图片描述

四、Lock锁

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

import java.util.concurrent.locks.ReentrantLock;

//解决线程安全问题的方式三：Lock锁
class Window5 implements Runnable {
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                //2.调用锁定方法：lock()
                lock.lock();
                if (ticket > 0) {

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

                    System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "张票！");
                    ticket--;
                } else
                    break;
            } finally {
                //3.调用解锁的方法：unlock()
                lock.unlock();
            }
        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Window5 w = new Window5();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

synchronized与Lock的对比

  1. Lock是显示锁(手动开启和关闭锁)，synchronized是隐式锁，出了作用域自动释放。
  2. Lock只有代码块锁，synchronized有代码块锁和方法锁。
  3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)。

优先使用顺序：Lock–>同步代码块(已经进入了方法体，分配了相应资源)–>同步方法(在方法体之外)。

import java.util.concurrent.locks.ReentrantLock;
/**
 * 练习：银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。
 * 分析：是否是多线程问题？  是，因为有两个账户
 * 是否有共享数据？    有，账户余额就是
 * 是否有线程安全问题？ 有
 * 需要考虑如何解决线程安全问题？ 同步机制：三种方式(同步代码块、同步方法、Lock锁)
 */
class Account {
    private double balance;
    public Account(double balance) {
        this.balance = balance;
    }
    //存钱的方法
    //public synchronized void deposit(double amt) {
    public void deposit(double amt) {
        if (amt > 0) {
            balance += amt;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "存钱成功,账户余额为：" + balance);
        }
    }
}
class Customer implements Runnable {
    private Account account;
    public Customer(Account account) {
        this.account = account;
    }

    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        try {
            lock.lock();
            for (int i = 0; i < 3; i++) {
                account.deposit(1000);
            }
        } finally {
            lock.unlock();
        }
    }
}
public class ThreadDemo4 {
    public static void main(String[] args) {
        Account account = new Account(0);
        Customer c = new Customer(account);

        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        t1.setName("客户一");
        t2.setName("客户二");
        t1.start();
        t2.start();
    }
}

五、线程的通信

常用方法

  • wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
  • notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待。
  • notifyAll()：唤醒正在排队等待资源的所有线程结束等待。

注意：这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。调用这三个方法的必要条件是：当前线程必须具有该对象的监控权(加锁)。

//线程通信的例子：使用两个线程打印 1-100。线程1, 线程2 交替打印
class Number implements Runnable {
    private int number = 1;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                obj.notify();
                if (number <= 100) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();
    }
}

sleep()和wait()的异同

相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态，并释放同步监视器。

不同点：（1）两个方法的声明位置不同：Thread类中声明sleep()，Object类中声明wait()。（2）调用的要求不同：sleep()可以在任何需要的场景下调用；而wait()必须使用在同步代码块或同步方法中。（3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，而wait()会释放锁。

lets go
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java多线程】并发编程不得不知的重要概念(持续更新)
墩墩分墩
07-24 731
1. 串行：一个线程执行到底，相当于单线程。 2. 并发：多个线程交替执行，抢占cpu的时间片，但是速度很快，在外人看来就像是多个线程同时执行。 3. 并行：多个线程在不同的cpu中同时执行。
多线程基础、JUC锁、同步容器、线程池
07-11
多线程基础、JUC锁、同步容器、线程池
[Java]线程生命周期与线程通信
进步*于辰的博客
04-27 1760
出于个人知识掌握程度与时间成本等多方面整体考虑，本篇文章对线程生命周期与线程通信的阐述并非非常详细，故可能并不适合所有博友，一些知识点在文中给出的【启发博文】中可能更容易找到答案。 如果文中阐述有不妥或不对的，多多交流。
JUC学习笔记一：复习多线程操作资源类的方法
qq_31314141的博客
02-04 762
高内聚，低耦合 所谓高内聚，低耦合就是每个程序要实现的特定功能要尽量多的在自己的内部完成，对外部提供很少量的接口以便调用。 并行和并发 并行即多个任务在自己的分配的各自的资源上执行，即多个任务同时跑，互不冲突。 并发即多个任务在统一的一个资源内执行，多个任务会抢占同一资源，在cpu中体现为交替执行，并不能同时执行，但是cpu在多个线程中切换的速度会非常快，所以宏观上看似是同时的。 最大的区别体现在...
JUC笔记(一)多线程的认识
-
03-18 473
JUC是java.uitl.concurrent包下的一系列的的并发编程的包。 线程和进程 线程 在操作系统中，线程是比进程更小的能够独立运行的基本单位。同时，它也是CPU调度的基本单位。线程本身基本上不拥有系统资源，只是拥有一些在运行时需要用到的系统资源，例如程序计数器，寄存器和Java虚拟机栈等。一个进程中的所有线程可以共享进程中的所有资源。 线程与进程相似，但线程是一个比进程更小的...
JUC学习笔记二Java中的线程
JMU_software19的博客
11-20 368
创建和运行线程 方法一，直接使用 Thread // 构造方法的参数是给线程指定名字，推荐 Thread t1 = new Thread("t1") { @Override // run 方法内实现了要执行的任务 public void run() { log.debug("hello"); } }; t1.start(); 方法二，使用 Runnable 配合 Thread把【线程】和【任务】（要执行的代码）分开 // 创建任务对象 Runnable task2 = new
【java多线程】1 Thread、线程池、同步总结
努力充实，远方可期
04-24 1055
Thread类 线程创建与启动 创建：写到Thread对象.run()方法里。 启动：调用Thread对象.start() Thread构造器 构造方法 Thread()：创建新的Thread对象 Thread(String threadname)：创建线程并指定线程实例名 Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法 Thre...
JUC学习笔记（一）多线程基本知识
slxysyka的博客
03-07 429
多线程知识 尚硅谷学习笔记 第一节 基础概念 1、程序、进程、线程 ①程序 程序从开发到发布的过程：源程序（源代码） → 打包封装 → 应用软件 笼统的来说，源程序、应用软件都可以称之为『程序』。 相对于进程、线程来说，程序是一个静态的概念。 ②进程 内部视角：程序运行起来就是一个进程。所以相对于程序来说，进程是一个动态的概念。 外部视角：站在操作系统的层次上来说，现代的大型操作系统都是支持多进程模式运行的，这样操作系统就可以同时执行很多个任务。 ③线程 在一个进程中，需要同时处理多个不同任务，
分享java多线程学习笔记
yhz_1的博客
11-14 150
分享java多线程学习笔记（有不完整的地方抽时间补充） 一、线程状态： 1.new 初始 2.runnable 运行 3.blocked 阻塞 4.waiting 等待 5.time_waiting 超时等待 6.terminated 终止 二、创建线程方式： 1.继承Thread，重写父类run方法。 2.实现Runable接口，并实现run方法。 3.线程池Executors.newSingleThreadExecutor(); 三、线程挂起、唤醒： 1.thread.suspend() --
JUC多线程学习个人笔记
07-08
Java Util Concurrent（JUC）是Java并发编程的核心库，提供了丰富的工具和接口，使得开发者能够高效、安全地处理多线程环境中的并发问题。以下将详细介绍JUC中的关键概念和特性。 1. **线程池**：JUC通过Executor...
JUC代码演示 Java多线程并发
05-03
JUC代码演示 Java多线程并发 源于B站https://www.bilibili.com/video/BV1Kw411Z7dF/?p=32&spm_id_from=333.1007.top_right_bar_window_history.content.click课程自我项目记录。 适合有一定基础的朋友。
JUC代码收集，java高并发多线程学习
03-31
本资源"JUC代码收集，java高并发多线程学习"显然是一个专注于探讨和学习JUC库的资料包。 JUC库包含多个子包，如`concurrent`, `atomic`, `locks`等，每个子包都有其特定的功能和用途： 1. **concurrent**：这是JUC...
JUC学习笔记（Java多线程）
07-04
总的来说，JUC学习笔记涵盖了Java多线程编程的主要方面，包括线程的创建与管理、同步机制、并发容器以及协调工具的使用，这些都是提升Java并发编程能力的关键知识点。通过深入理解和熟练应用这些工具，开发者可以更...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1100
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 413
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 747
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 76
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
Java JUC并发编程实例：守护线程与Synchronized锁
这个资源通过具体的代码实例，展示了Java多线程编程中的基础概念，包括如何使用用户线程和守护线程，以及如何利用JUC库中的同步机制（如`synchronized`和`Lock`）来处理并发场景中的数据一致性问题。这些知识对于有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值