【JUC】学习JUC之前必备的线程知识

最新推荐文章于 2024-01-17 16:59:51 发布
最新推荐文章于 2024-01-17 16:59:51 发布
阅读量220 收藏
点赞数
分类专栏： # JUC java 文章标签： 多线程 java 并发编程 多进程 juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40742223/article/details/110659096
版权
java 同时被 2 个专栏收录
69 篇文章 4 订阅
订阅专栏
JUC
5 篇文章 0 订阅
订阅专栏

文章目录

什么是JUC

image-20201203194639787

JUC就是java.util的这三个工具包

都是关于线程同步工具包

学习之前的回顾

回顾之前的基础知识:线程实现的三种方式

线程我们知道有三种实现方式

  • 继承Thread类
  • 实现Runnable接口
  • 实现Callable接口

分别演示一下三种实现线程实现的方式

继承的方式实现创建线程

package jucTest2;



/**
 * @author 雷雨
 * @date 2020/12/3 19:51
 * 使用继承Thread的方式实现一个线程
 */
public class MyThread1 extends Thread{
    public static void main(String[] args) {
        Thread date = new Data1();
        date.setName("线程A");
        date.start();
        Thread data2 = new Data1();
        data2.setName("线程B");
        data2.start();


    }
}
class Data1 extends Thread{
    public void run(){
        System.out.println("雷雨向您问好");
        System.out.println(Thread.currentThread().getName());
    }
}

实现Runnable的方式实现一个多线程

package jucTest2;

/**
 * @author 雷雨
 * @date 2020/12/3 20:00
 */
public class MyThread2 {
    public static void main(String[] args) {
        Data2 data2 = new Data2();
        //该线程执行十次
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data2.run();
            }
        }).start();
    }
}
class Data2 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
        System.out.println("雷雨向您问好");
    }
}

image-20201203200244219

使用实现Callable的方式来实现线程

package jucTest2;

import java.util.concurrent.Callable;

/**
 * @author 雷雨
 * @date 2020/12/3 20:03
 * 使用Callable的方式实现线程
 * Callable是可以得到返回值的
 */
public class MyThread3 {
    public static void main(String[] args) {
        Data3 data3 = new Data3();
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                try {
                    Integer call = data3.call();
                    System.out.println(call);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }

    }

}
class Data3 implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("当前线程的名字是"+Thread.currentThread().getName());
        return 123;
    }
}

image-20201203201809688

可以发现这里出现了线程同步的问题，那么之后接着会介绍如何解决线程安全问题。

注意：在实际的开发过程中，我们要面向OOP的编程思想，也就是将有线程需求的资源类单独实现，而对于线程的操作放在其他类中，如上面三种方式演示的那样，资源类仅仅是实现了线程的功能的，而具体的操作逻辑放在了主操作类中。

三种线程的三种方式的区别:

  1. 继承Thread的方式实现多线程，那么要实现线程的类就不能继承其他类了（Java单继承的特性），其他两种方式还可以继承其他类。
  2. Callable的方式实现多线程比实现Runnable的方式多一个返回值，并且call（）可以抛出异常
  3. 访问当前的线程的线程名，如果继承的是Thread类，那么可以直接使用this.getName，如果使用实现Runnable接口或者实现Callable的方式，那么就要使用Thread.getcurrentThread().getName()。

进程和线程

检测自己是否对于一个知识或者技术很熟悉，那么就看自己能不能一口气将这个技术讲清楚。

什么是进程，什么是线程？

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

举一个形象的栗子：

比如我们经常使用的QQ就是一个进程，但是QQ有很多功能，发送消息和打视频电话都是独立的线程。

进程和线程有什么区别和联系？

1) 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.

  1. 线程的划分尺度小于进程，使得多线程程序的并发性高。

  2. 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

  3. 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。**但是线程不能够独立执行，**必须依存在应用程序中，由应用程序提供多个线程执行控制。

  4. 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

Java真的能开启线程吗？

Java其实不能自己开启一个线程，而是通过Java的一个本地方式start0()来开启线程。

image-20201203202701706

并发和并行

并行：多个线程真正的同时运行。（比如CPU有多个核就可以处理多条线程）

并发：多个线程高速的轮询来执行线程，从外部看起来好像多个线程同时执行，其实是多个线程执行时间片的时间就让出CPU给别的线程执行机会。

public static void main(String[] args) {   System.out.println(Runtime.getRuntime().availableProcessors());
}

wait和sleep的区别?

  1. wait是Object类的方法，而sleep是Thread的方法。
  2. wait()方法会释放锁资源，而sleep()方法不会释放锁资源。
  3. 使用的区域不同，wait()方法必须在同步代码块中,而sleep()可以在任何地方谁。
  4. wait()方法不需要捕获异常;sleep()必须捕获异常。

线程同步

实现线程同步的方式，常见的方式就是加锁。

实现线程同步方式一:synchronized

先说最常见的加synchronized锁的方式实现线程同步。

假想的题目要求:

两个线程

一个线程实现对数+1操作

另一个线程实现对数-1操作

保证加线程必须是num为0是执行+1操作

num不为0时执行-1操作

package jucTest2;

/**
 * @author 雷雨
 * @date 2020/12/3 20:42
 */
public class SynchronizedDemo1 {
    public static void main(String[] args) {
        Data4 data4 = new Data4();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data4.pulsOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程A执行的是加法").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data4.deOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程B执行的是减法").start();

    }
}
class Data4{
    //初始化资源num为0
    private int num = 0;

    //+1方法
    public synchronized void pulsOne() throws InterruptedException {
        if (num != 0){
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"当前num操作后为  "+num);
        this.notifyAll();
    }

    //-1方法
    public synchronized void deOne() throws InterruptedException {
        if (num == 0){
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"当前num操作后为  "+num);
        this.notifyAll();
    }

}

执行结果如下:两个线程交替执行

image-20201203204920735

这里演示的是两个线程,一个消费者线程,一个生产者线程，我们能够正确执行的操作。但是如果是多个生产者和多个消费者同时操作资源会不会出现问题呢？

package jucTest2;

/**
 * @author 雷雨
 * @date 2020/12/3 20:42
 */
public class SynchronizedDemo1 {
    public static void main(String[] args) {
        Data4 data4 = new Data4();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data4.pulsOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程A执行的是加法").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data4.pulsOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程C执行的是加法").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data4.deOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程B执行的是减法").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data4.deOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程D执行的是减法").start();

    }
}
class Data4{
    //初始化资源num为0
    private int num = 0;

    //+1方法
    public synchronized void pulsOne() throws InterruptedException {
        if (num != 0){
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"当前num操作后为  "+num);
        this.notifyAll();
    }

    //-1方法
    public synchronized void deOne() throws InterruptedException {
        if (num == 0){
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"当前num操作后为  "+num);
        this.notifyAll();
    }

}

image-20201203205220611

观察结果:发现出现了问题，出现了异常数2，发现在执行了一次了一次加操作后可能出现线程又执行了一次加操作，这是我们不想看到的情况的。

导致的原因就是发生了虚假唤醒

image-20201203210132597

详细解释上述的虚假唤醒的问题的原因:wait方法导致的虚假唤醒

wait方法的执行其实可以分为三步:

  1. 释放锁,并阻塞
  2. 等待条件cond发生
  3. 获取通知后,竞争获取锁继续执行

我们上述代码中出现2的原因详解:

当加线程A要执行的时候发现了num!=0，然后会进入到wait方法进行等待（进入了阻塞队列），这时释放锁资源，然后加线程C也可能获取了锁,而加线程C也不满足条件,也进入了wait方法并释放锁资源，然后这时减线程B获取了锁资源，（因为num！=0），因此减线程正常执行，减线程执行之后，可能加线程A竞争之后获取了锁资源，并执行，而线程C在之后也获取了锁资源，而只是唤醒之后不会在判断条件num！=0是否满足，而是直接执行后续的代码。

这样的操作就导致了虚假唤醒。

怎么避免虚假唤醒？

使用while来判断cond条件就能避免虚假唤醒的问题。

原因是：while循环本身就是一个自旋的操作，会循环判断条件是否满足。

将上述代码改造一下：

package jucTest2;

/**
 * @author 雷雨
 * @date 2020/12/3 20:42
 */
public class SynchronizedDemo1 {
    public static void main(String[] args) {
        Data4 data4 = new Data4();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data4.pulsOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程A执行的是加法").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data4.pulsOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程C执行的是加法").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data4.deOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程B执行的是减法").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data4.deOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程D执行的是减法").start();

    }
}
class Data4{
    //初始化资源num为0
    private int num = 0;

    //+1方法
    public synchronized void pulsOne() throws InterruptedException {
        while (num != 0){
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"当前num操作后为  "+num);
        this.notifyAll();
    }

    //-1方法
    public synchronized void deOne() throws InterruptedException {
        while (num == 0){
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"当前num操作后为  "+num);
        this.notifyAll();
    }

}

实现实现同步方式二:Lock锁

package jucTest2;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 雷雨
 * @date 2020/12/3 20:42
 * 使用Lock锁的方式实现线程同步
 */
public class LockDemo1 {
    public static void main(String[] args) {
        Data5 data5= new Data5();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data5.pulsOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程A执行的是加法").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data5.pulsOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程C执行的是加法").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data5.deOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程B执行的是减法").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data5.deOne();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程D执行的是减法").start();

    }
}

class Data5{
    //初始化资源num为0
    private int num = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    //+1方法
    public  void pulsOne() throws InterruptedException {
        lock.lock();
        while (num != 0){
            condition.await();
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"当前num操作后为  "+num);
        condition.signalAll();
        lock.unlock();
    }

    //-1方法
    public  void deOne() throws InterruptedException {
        lock.lock();
        while (num == 0){
            condition.await();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"当前num操作后为  "+num);
        condition.signalAll();
        lock.unlock();
    }

}

小结:

不论是传统的synchronized的方式实现线程的同步还是使用Lock锁的方式实现线程同步,都需要经历如下过程

  1. 加锁，判断等待(判断是否需要等待)
  2. 执行业务代码
  3. 唤醒其他线程，解锁

使用synchronized和Lock锁的区别?

  1. synchronized不能精确的判断锁的状态，而Lock锁是能够精确判断锁的状态的。synchronized不需要程序员自身对于锁状态进行改变，而Lock锁，需要手动的加锁和解锁。
  2. synchronized实现线程同步的话，直接使用Object类的wait（）方法和notifyAll（）方法，而Lock要实现线程同步时，必须借助condition监视器。
炒冷饭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
JUC线程高级
02-27
JUC线程高级,
jucproject:JUC进阶
03-08
Java并发编程是Java开发者必备的技能之一，而Java Concurrency Utility（JUC）库则是Java并发编程的核心组件。在Java中，JUC提供了丰富的工具类和接口，使得开发者能够更高效、更安全地进行多线程编程。本项目...
进程与线程
dd8378的博客
08-06 170
进程概念　　进程是表示资源分配的基本单位，又是调度运行的基本单位。例如，用户运行自己的程序，系统就创建一个进程，并为它分配资源，包括各种表格、内存空间、磁盘空间、I／O设备等。然后，把该进程放人进程的就绪队列。进程调度程序选中它，为它分配CPU以及其它有关资源，该进程才真正运行。所以，进程是系统中的并发执行的单位。　　在Mac、Windows NT等采用微内核结构的操作系统中，进程...
线程和进程的区别
yuer7916555的博客
09-25 154
&lt;script&gt;show_img("a1218915564");&lt;/script&gt; 进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于： 简而言之,一个程序至少有一个进程,一个进程至少有一个线程. 线程的划分尺度小于进程，使得多线程程序的并发性高。 另外，进程在执行过程中拥有独立的内存单元，而...
线程与进程的区别
weixin_69145754的博客
06-26 994
进程与线程的区别
狂神JUC并发笔记大全+Linux等资料
08-07
"狂神说Linux课堂笔记"可能涵盖了Linux的基本操作、系统管理、文件系统、进程管理、网络配置、 Shell脚本编写等内容，这些都是开发者必备的Linux基础知识。 【Java面试题】 "Java面试题总结：基础及语法篇169道.pdf...
MySQL、JVM、RocketMQ、JUC、设计模式、数据结构与算法学习总结.zip
02-22
同时，了解如何进行备份恢复、性能监控以及安全性管理也是使用MySQL必备的知识。 JVM（Java虚拟机）是Java程序运行的平台，它负责解释执行字节码并提供内存管理。学习JVM需要了解类加载机制、垃圾收集（GC）算法、...
架构师知识谱系梳理，包含Java core, JUC, JVM, MySQL，MQ, redis，分布式相关等各种知.zip
最新发布
02-23
以上各个领域的知识是架构师必备的技能，通过深入学习和实践，不仅可以提升个人技术水平，还能为企业的软件系统提供更加健壮和高效的设计方案。在这个过程中，"kwan1117"可能包含了与这些主题相关的教程、代码示例或...
谈一谈对JUC的理解Java系列2021.pdf
04-27
总结来说，理解JUC是Java开发者必备的技能之一，它可以帮助我们编写更加高效、安全的并发代码。`volatile`关键字提供了一种相对轻量级的同步机制，但无法解决原子性问题；而原子变量类结合CAS算法，可以解决如`i++`...
进程和线程有什么区别？
csdssdn的博客
07-02 4253
进程是正在运行的程序实例线程是进程中执行执行任务的基本单位也就是说一个运行的程序至少包含一个进程，一个进程至少包含一个线程，线程不能独立于进程存在从计算机角度来说进程（Process）是操作系统分配资源得基本单位，一个进程拥有的资源有自己的堆、栈、虚存空间（页表）、文件描述符等信息 ，从编程的角度来看待进程，可以将其看做是一个类或者一个PCB（Process Control Block）进程控制块的结构体。此结构体大致包含以下内容：1. 进程编号PID 进程的身份标识2. 进程的状态3. 进程状态4. 就
进程与线程的区别
记录各种Bug解决案例及日常学习内容
07-21 8032
线程是进程中执行运算的最小单位，是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。好处（1）易于调度。（2）提高并发性。通过线程可方便有效地实现并发性。进程可创建多个线程来执行同一程序的不同部分。（3）开销少。创建线程比创建进程要快，所需开销很少。（4）利于充分发挥多处理器的功能。...
带你深刻认识一下synchronized和Lock
雷霆嘎巴
06-14 174
一、认识线程 1.1线程如何启动 public synchronized void start() { /** * This method is not invoked for the main method thread or "system" * group threads created/set up by the VM. Any new functionality added * to this method in th
一万小时学编程：Java线程池原理
the Commitments的博客
09-18 153
一万小时学编程系列 《一万小时定律》格拉德威尔：“人们眼中的天才之所以卓越非凡，并非天资超人一等，而是付出了持续不断的努力。1万小时的锤炼是任何人从平凡变成世界级大师的必要条件。” 文章目录一万小时学编程系列前言一、并发队列1.概念2.分类二、线程池简介三、线程池原理1.ThreadPoolExecutor核心类2.线程池原理图3.线程池实例总结 前言 线程池是学习Java的重点也是难点，在面试中也会经常问到，尤其是对“高并发”有较高要求的企业，所以学好线程池原理很重要，本文是我参考大佬的博客写的，后
JUC线程池
会走的桃子的博客
11-30 1073
Callable 是一个接口，它只包含一个call()方法。Callable是一个返回结果并且可能抛出异常的任务。 为了便于理解，我们可以将Callable比作一个Runnable接口，而Callable的call()方法则类似于Runnable的run()方法。
JUC 线程池
这个需求，做不了
01-17 975
日志反应的比较清楚，我们的线程池只有2个线程，线程2 执行了两个提交的任务，f1 的结果为任务返回的结果，f2 的结果为我们提交任务是传的结果，f3 不返回结果（因为 Runnable 接口的 run 方法返回值为 void）这里的线程名称格式为：pool-[虚拟机中线程池编号]-thread-[线程编号]，如 pool-1-thread-1，在实际使用时我们最好自定义线程名称，以提高日志的可读性，避免日后排查日志无法第一时间确定执行的线程。如果没有则继续等待，直到有空闲线程执行。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

炒冷饭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值