JUC并发编程笔记

已于 2022-06-27 23:59:32 修改
阅读量218 收藏
点赞数
文章标签： java
于 2022-06-27 00:25:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lzp_csdn1/article/details/125476554
版权

JUC并发编程

一 多线程的实现方式

① 继承Thread类

public class ThreadDemo {
    public static void main(String[] args) {
        // 4.创建Thread类的子类对象
        MyThread myThread = new MyThread();
        // 5.调用start()方法开启线程
        myThread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("我是主线程" + i);
        }
    }
}

/**
 * 1. 新建MyThread类继承Thread类
 */
class MyThread extends Thread {
    /**
     * 2.重写run方法
     */
    @Override
    public void run() {
        // 3.将要执行的代码写在run方法中
        for (int i = 0; i < 100; i++) {
            System.out.println("我是线程" + i);
        }
    }
}

② 实现Runnable接口

public class ThreadDemo2 {
    public static void main(String[] args) {
        // 4.创建Runnable的子类对象
        MyRunnable myRunnable = new MyRunnable();
        // 5.将子类对象当做参数传递给Thread的构造函数,并开启线程
        new Thread(myRunnable).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我是主线程" + i);
        }
    }
}

/**
 * 1.MyRunnable实现Runnable接口
 */
class MyRunnable implements Runnable {
    /**
     * 2.重写run方法
     */
    @Override
    public void run() {
        // 3.将要执行的代码写在run方法中
        for (int i = 0; i < 1000; i++) {
            System.out.println("我是线程" + i);
        }
    }
}

③ 通过Callable和FutureTask创建线程

public class ThreadDemo3 {
    public static void main(String[] args) {
        // 3.创建callable接口实现类的对象
        MyCallable m = new MyCallable();
        // 4.将此callable的对象作为参数传入到FutureTask构造器中,创建FutureTask的对象

        FutureTask futureTask = new FutureTask(m);
        // 5.将FutureTask对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()方法
        // FutureTask类继承了Runnable接口
        new Thread(futureTask).start();

        // 6.获取callable接口中call方法的返回值
        try {
            // get()方法返回值即为FutureTask构造器参数callable实现类重写的call方法的返回值
            Object sum = futureTask.get();
            System.out.println("总和是:" + sum);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/**
 * 1.创建一个实现Callable接口的实现类
 */
class MyCallable implements Callable {
    /**
     * 实现call方法,将此线程需要执行的操作声明在call()中
     *
     * @return
     * @throws Exception
     */
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
            sum += i;
        }
        return sum;
    }
}

二 线程间通信

① 虚假唤醒问题

多线程环境下，有多个线程在等待，若有一个线程唤醒了他们，由于把所有线程都唤醒了，但是只有其中一部分是有用的唤醒操作，其余的唤醒都是无用功，对于不应该被唤醒的线程而言，便是虚假唤醒。

A: synchronized版本实现
package com.lzp.juc.thread;

/**
 * 1.题目:
 * 现在两个线程,可以操作初始值为0的一个变量，实现一个线程对该变量加1,
 * 一个线程对该变量减1,交替执行,来10轮,变量的初始值为0
 * 2.思想:
 * 1.在高内聚低耦合的前提下,线程->操作->资源类
 * 2.判断操作唤醒[生产消费中]
 * 3.多线程交互中,必须要放置多线程的虚假唤醒,也即(判断使用while,不能使用if)
 *
 * @author lzp
 * @date 2022/6/26 23:15:41
 */
public class ThreadWaitNotifyDemo {
    public static void main(String[] args) {
        AirCondition airCondition = new AirCondition();
        new Thread(() -> {
            for (int i = 1; i < 11; i++) {
                airCondition.increment();
            }
        }, "线程A").start();

        new Thread(() -> {
            for (int i = 1; i < 11; i++) {
                airCondition.decrement();
            }
        }, "线程B").start();
        new Thread(() -> {
            for (int i = 1; i < 11; i++) {
                airCondition.increment();
            }
        }, "线程C").start();
        new Thread(() -> {
            for (int i = 1; i < 11; i++) {
                airCondition.decrement();
            }
        }, "线程D").start();
    }
}

class AirCondition {

    private int number = 0;

    /**
     * 变量加1
     */
    public synchronized void increment() {
        // 1.判断
        if (number != 0) {
        while (number != 0) {
            try {
                // wait方法在哪等待就在哪里唤醒，wait方法应该始终再循环中使用
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 2.干活
        number++;
        System.out.println(Thread.currentThread().getName() + ":" + number);
        //3.唤醒
        this.notifyAll();
    }

    /**
     * 变量减1
     */
    public synchronized void decrement() {
        if (number == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number--;
        System.out.println(Thread.currentThread().getName() + ":" + number);
        this.notifyAll();
    }

}

执行结果

线程A:1
线程B:0
线程A:1
线程B:0
线程A:1
线程B:0
线程A:1
线程B:0
线程A:1
线程B:0
线程A:1
线程B:0
线程A:1
线程C:2
线程A:3
线程B:2
线程B:1
线程B:0
线程A:1
线程D:0
线程C:1
线程D:0
线程A:1
线程B:0
线程D:-1
线程D:-2
线程D:-3
线程D:-4
线程D:-5
线程D:-6
线程D:-7
线程D:-8
线程C:-7

如何避免虚假唤醒问题？

使用while循环去循环判断一个条件，而不是使用if只判断一次条件；即wait()要在while循环中。

调整后

package com.lzp.juc.thread;

/**
 * 1.题目:
 * 现在两个线程,可以操作初始值为0的一个变量，实现一个线程对该变量加1,
 * 一个线程对该变量减1,交替执行,来10轮,变量的初始值为0
 * 2.思想:
 * 1.在高内聚低耦合的前提下,线程->操作->资源类
 * 2.判断操作唤醒[生产消费中]
 * 3.多线程交互中,必须要放置多线程的虚假唤醒,也即(判断使用while,不能使用if)
 *
 * @author lzp
 * @date 2022/6/26 23:15:41
 */
public class ThreadWaitNotifyDemo {
    public static void main(String[] args) {
        AirCondition airCondition = new AirCondition();
        new Thread(() -> {
            for (int i = 1; i < 11; i++) {
                airCondition.increment();
            }
        }, "线程A").start();

        new Thread(() -> {
            for (int i = 1; i < 11; i++) {
                airCondition.decrement();
            }
        }, "线程B").start();
        new Thread(() -> {
            for (int i = 1; i < 11; i++) {
                airCondition.increment();
            }
        }, "线程C").start();
        new Thread(() -> {
            for (int i = 1; i < 11; i++) {
                airCondition.decrement();
            }
        }, "线程D").start();
    }
}

class AirCondition {

    private int number = 0;

    /**
     * 变量加1
     */
    public synchronized void increment() {
        // 1.判断
        /*if (number != 0) {*/
        while (number != 0) {
            try {
                // wait方法在哪等待就在哪里唤醒，wait方法应该始终再循环中使用
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 2.干活
        number++;
        System.out.println(Thread.currentThread().getName() + ":" + number);
        //3.唤醒
        this.notifyAll();
    }

    /**
     * 变量减1
     */
    public synchronized void decrement() {
        /*if (number == 0) {*/
        while (number == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number--;
        System.out.println(Thread.currentThread().getName() + ":" + number);
        this.notifyAll();
    }

}
B: Lock版本实现
package com.lzp.juc.thread;

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

/**
 * 使用Lock代替synchronized来实现
 *
 * @author lzp
 * @date 2022/6/26 23:50:48
 */
public class ThreadWaitNotifyDemo2 {
    public static void main(String[] args) {
        AirCondition2 airCondition2 = new AirCondition2();
        new Thread(() -> {
            for (int i = 1; i < 11; i++) {
                airCondition2.increment();
            }
        }, "线程A").start();

        new Thread(() -> {
            for (int i = 1; i < 11; i++) {
                airCondition2.decrement();
            }
        }, "线程B").start();
        new Thread(() -> {
            for (int i = 1; i < 11; i++) {
                airCondition2.increment();
            }
        }, "线程C").start();
        new Thread(() -> {
            for (int i = 1; i < 11; i++) {
                airCondition2.decrement();
            }
        }, "线程D").start();
    }
}

class AirCondition2 {
    private int number = 0;
    // 定义Lock锁对象
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    // 生产者,如果number=0就 number++
    public void increment() {
        // 加锁
        lock.lock();
        try {
            // 1.判断
            while (number != 0) {
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 2.干活
            number++;
            System.out.println(Thread.currentThread().getName() + ":" + number);
            // 3.唤醒
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }

    // 消费者,如果number=1,就 number--
    public void decrement() {
        // 加锁
        lock.lock();
        try {
            // 1.判断
            while (number == 0) {
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 2.干活
            number--;
            System.out.println(Thread.currentThread().getName() + ":" + number);
            // 3.唤醒
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }
}

② 线程间定制化通信

/**
 * 线程间定制化通信
 * 启动三个线程，按照如下要求操作：
 * AA线程打印5次，BB线程打印10次，CC线程打印15次
 * 执行10轮
 *
 * @author lzp
 * @date 2022/6/27 23:37:59
 */
public class ThreadCustomizedDemo {
    public static void main(String[] args) {
        CustomizeResource resource = new CustomizeResource();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                resource.print5(i);
            }
        }, "AA").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                resource.print10(i);
            }
        }, "BB").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                resource.print15(i);
            }
        }, "CC").start();
    }
}

/**
 * 资源类
 */
class CustomizeResource {
    // 定义flag
    private int flag = 1;
    // 创建lock锁
    private Lock lock = new ReentrantLock();
    // 创建三个condition，指定唤醒对应线程
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    /**
     * 打印5次
     *
     * @param loop 轮数
     */
    public void print5(int loop) {
        // 上锁
        lock.lock();
        try {
            // 判断flag，flag!=1时，线程等待
            while (flag != 1) {
                try {
                    c1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 干活，打印5轮
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() + " :: " + i + ", 轮数 :" + loop);
            }
            // 修改标志flag
            flag = 2;
            // 通知B线程
            c2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }

    /**
     * 打印10次
     *
     * @param loop 轮数
     */
    public void print10(int loop) {
        // 上锁
        lock.lock();
        try {
            // 判断flag，flag!=2时，线程等待
            while (flag != 2) {
                try {
                    c2.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 干活，打印10轮
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + " :: " + i + ", 轮数 :" + loop);
            }
            // 修改标志flag
            flag = 3;
            // 通知C线程
            c3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }

    /**
     * 打印15次
     *
     * @param loop 轮数
     */
    public void print15(int loop) {
        // 上锁
        lock.lock();
        try {
            // 判断flag，flag!=3时，线程等待
            while (flag != 3) {
                try {
                    c3.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 干活，打印15轮
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName() + " :: " + i + ", 轮数 :" + loop);
            }
            // 修改标志flag
            flag = 1;
            // 通知A线程
            c1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }

}
隐约雷鸣i
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java线程的6种状态详解及创建线程的4种方式
weixin_47661043的博客
09-14 1574
1、线程的定义 2、线程的6种状态及切换 3、线程的4种创建方式 4、线程相关常见面试题 1、线程的定义 概念：线程是进程中执行运算的最小单位，是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。 2、线程6种状态及切换 Java中线程的状态分为6种，定义在Thread类的State枚举中。 public class Th
JUC并发编程学习笔记
Melekh_的博客
02-26 492
一、什么是JUC JUC指的是：Java里的三个包 java.util.concurrent java.util.concurrent.atomic：原子性 java.util.concurrent.locks：lock锁 二、线程和进程 1.进程 程序执行的一次过程，一个进程包含一个或多个线程。进程是资源分配的单位。 2.线程 可以指程序执行过程中，负责实现某个功能的单位。线程是CPU调度和执行的单位。 3.并发 同一时刻，多个线程交替执行。（一个CPU交替执行线程） 4.并行 同一时
JUC编程学习笔记
aimerary的博客
05-31 286
JUC编程学习笔记什么是JUC线程和进程java能开启线程吗并发和并行线程的状态wait和sleepLock锁TestJUC01（synchronized锁）TestJUC02（Lock锁）synchronized和Lock的区别TestJUC03（生产者消费者问题synchronized版）Condition类TestJUC04（生产者消费者问题Lock锁）TestJUC05（Condition监视器实现精准唤醒，且不需要标识符）8锁（锁的8个问题）问题1、2：正常情况下，两个线程谁先执行？A线程执行时睡
JUC编程笔记
Ernie_linyerun的博客
03-03 148
Java多线程，JUC编程入门。
JUC学习笔记
市民景先生
03-12 1197
JUC主要是java8下的三个包 java.util.concurrent java.util.concurrent.atomic java.util.concurrent.locks java.util.concurrent.function 进程和线程 进程：一个程序，程序的集合 一个进程往往包含多个线程，至少包含一个 java默认有两个线程：main gc 线程：正在运行的程序，不如音乐播放器 java是开不了线程的，调用底层的c++调用的方法 并发编程：并发，并行 并
JUC底层的详细学习+狂神JUC笔记+全网最全
热门推荐
qq_41617848的博客
07-27 2万+
1、什么是JUC 源码+官方文档 JUC是 java util concurrent 面试高频问JUC~！ java.util 是Java的一个工具包~ 业务：普通的线程代码 Thread Runnable： 没有返回值、效率相比于Callable 相对较低！ 2、线程和进程 进程：一个程序，QQ.EXE Music.EXE；数据+代码+pcb 一个进程可以包含多个线程，至少包含一个线程！ Java默认有几个线程？2个线程！ main线程、GC线程 线程：开了一个进程Typora，写字，等待几分钟会进行
JUC并发编程
weixin_42049458的博客
09-04 252
锁的理解与使用 通过Synchronized理解锁 详细理解查看视频：8锁问题【狂神说Java】JUC并发编程最新版通俗易懂_哔哩哔哩_bilibili 被synchronized锁的对象是方法的调用者 如phone1.call()，那么锁定的是new出来的这个phone1，如果还有一个实例phone2，是不受phone1锁的影响的。 class Phone{ public synchronized void call(){ TimeUnit.SECONDS.sleep(3);
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
最全的并发编程JUC 笔记 Typora 版
10-03
JUC 笔记 基于JDK 17
JUC并发编程学习笔记(硅谷)
07-23
"JUC并发编程学习笔记(硅谷)"很可能包含了关于Java并发工具集（Java Util Concurrency, JUC）的深入理解和实战经验。JUC是Java标准库提供的一套强大的并发处理工具，它极大地简化了多线程编程，提高了程序的可读性...
JUC并发编程.md
01-28
JUC并发编程学习笔记，狂神说
并发编程、juc工具包源码分析笔记
11-03
Java 并发库（Java Util Concurrency, JUC）是 Java 平台中用于处理并发问题的核心工具包，提供了丰富的类和接口来简化并发编程。 在计算机系统中，进程是操作系统资源分配的基本单位，它拥有独立的内存空间，而...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 834
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 905
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1026
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 835
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
Java 线程池详解
qq_41591215的博客
07-13 966
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
【JAVA】相关程序组件
qq_44077764的博客
07-15 162
【JAVA】相关程序组件
【Java算法】前缀和 下
最新发布
2302_79806056的博客
07-18 881
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
黑马juc并发编程md笔记
09-22
黑马程序员的JUC并发教程一是关于并发编程的课程，包括了进程与线程、并行与并发、Java线程等内容。其中涵盖了创建和运行线程、线程的运行原理、线程的方法、线程状态等知识点。并发是指多个程序在同一时间段内在同...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值