JUC学习笔记(一)

最新推荐文章于 2023-06-14 16:55:02 发布
最新推荐文章于 2023-06-14 16:55:02 发布
阅读量141 收藏
点赞数
分类专栏： JUC 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014742343/article/details/118546536
版权

目录

一、JUC是什么

1. juc（java.util.concurrent）

2. 进程、线程回顾

3. 线程状态

4. wait、sleep的区别

5. 并发和并行的区别

6. 多线程使用技巧

二、Lock接口

1. Lock是什么

2. Lock接口的实现

3. 卖票案例

三、线程间通信

1. 生产者+消费者

四、线程间定制化调用通信

一、1、JUC是什么

1. juc（java.util.concurrent）

是java.util.concurrent在并发编程中使用的工具类，jdk1.5开始出现的。

2. 进程、线程回顾

进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。 (简单理解就是电脑上的运行程序，如360杀毒软件、QQ音乐、chrome浏览器等)

线程：通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程可以利用进程所拥有的资源，在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位，由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统多个程序间并发执行的程度。(相当于360杀毒软件既可以清理垃圾、又可以扫描病毒。清理垃圾操作可以看做是一个线程在工作、扫描病毒也是一个线程在工作)

3. 线程状态

Thread.State

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW, //新建

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE, //准备就绪

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED, //阻塞(线程等待执行)

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING, //不见不散(线程等待唤醒)

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING, //过时不候(超过等待唤醒时间)

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED; //终结
    }

4. wait、sleep的区别

wait：释放锁等待(放开手去睡)

sleep：不释放锁等待(握紧手去睡，醒了手里还有锁)

5. 并发和并行的区别

并发：同一时刻多个线程在访问同一个资源，多个线程对一个点操作。比如：春运抢票、电商秒杀

并行：多项工作一起执行，之后再汇总。比如：泡方便面，可以一边撕开方便面包装加调料包，一边烧开水

6. 多线程使用技巧

 【多线程编程的企业级套路+模板】

线程 -->操作（对外暴露的调用方法）-->资源类 

二、Lock接口

1. Lock是什么

Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象Condition 。

2. Lock接口的实现

ReentrantLock可重入锁

class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...
 
   public void m() {
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
 }
  • synchronized与Lock的区别

1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类；

2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；

3.synchronized会自动释放锁(线程执行完同步代码会释放锁 ；线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；

4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；

5.synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）

6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

3. 卖票案例

（1）使用synchronized方案

/**
 * 资源类
 */
class Ticket{

    //总共有30张票
    private int number = 30;

    //对外暴露的调用的方法
    public synchronized void saleTicket(){

       if(number > 0){
           System.out.println(Thread.currentThread().getName() + "\t卖出第：" + (number--) + "\t还剩下：" + number);
       }

    }
}

/**
 *题目：三个售票员   卖出   30张票
 * 【多线程编程的企业级套路+模板】
 * 1.在高内聚低耦合的前提下，线程    操作(对外暴露的调用方法)     资源类
 */
public class SaleTicket {

    public static void main(String[] args) {

        //资源类
        Ticket ticket = new Ticket();

        //A售票员
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <=40; i++) {
                    ticket.saleTicket();
                }
            }
        }, "A").start();

        //B售票员
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <= 40; i++) {
                    ticket.saleTicket();
                }
            }
        }, "B").start();

        //C售票员
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <=40; i++) {
                    ticket.saleTicket();
                }
            }
        }, "C").start();

    }

（2）使用juc中lock锁方案

/**
 * 资源类
 */
class TicketLock{

    private int number = 30;

    Lock lock  = new ReentrantLock();

    //对外暴露的调用方法
    public void saleTicket(){
        try {
            lock.lock();//对需要加锁的加锁处理
            System.out.println(Thread.currentThread().getName() + "\t卖出第：" + (number--) + "\t还剩下：" + number);
        } finally {
            lock.unlock(); //释放锁
        }
    }
}

/**
 *题目：三个售票员   卖出   30张票
 * 【多线程编程的企业级套路+模板】
 * 1.在高内聚低耦合的前提下，线程    操作(对外暴露的调用方法)     资源类
 */
public class SaleTicket {

    public static void main(String[] args) {

        /********使用juc中lock锁方式********/
        Ticket ticket = new Ticket();
        new Thread(() -> {for (int i = 0; i <= 40; i++) ticket.saleTicket();}, "A").start();
        new Thread(() -> {for (int i = 0; i <= 40; i++) ticket.saleTicket();}, "B").start();
        new Thread(() -> {for (int i = 0; i <= 40; i++) ticket.saleTicket();}, "C").start();


    }

执行结果：

三、线程间通信

【多线程编程的企业级套路+模板】

1、判断 2、干活 3、通知

【多线程之间的虚假唤醒】

判断不能使用if，需要使用while

1. 生产者+消费者

(1) synchronizd、wait()、notifyAll()


/**
 * 资源类
 */
class AdditionAndSubtraction{

    private int number = 0;

    //number加1
    public synchronized void increment() throws InterruptedException {
        //判断
        while(number != 0){
            this.wait();
        }
        //干活
        number++;
        System.out.println(Thread.currentThread().getName() + "\t" + number);
        //通知
        this.notifyAll();
    }

    //number减1
    public synchronized void decrement() throws InterruptedException {
        //判断
        while(number == 0){
            this.wait();
        }
        //干活
        number--;
        System.out.println(Thread.currentThread().getName() + "\t" + number);
        //通知
        this.notifyAll();
    }

}


/**
 * 题目：现在两个线程，可以操作初始值为零的一个变量，
 * 实现一个线程对该变量加1，一个线程对该变量-1，
 * 实现交替，来10轮，变量初始值为0.
 *      1.高内聚低耦合前提下，线程操作资源类
 *      2.判断/干活/通知
 *      3.防止虚假唤醒(判断只能用while，不能用if)
 * 知识小总结：多线程编程套路+while判断+juc
 */
public class ProducersAndConsumersTest {

    public static void main(String[] args) {
        AdditionAndSubtraction additionAndSubtraction = new AdditionAndSubtraction();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        additionAndSubtraction.increment();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        additionAndSubtraction.decrement();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "B").start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        additionAndSubtraction.increment();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "C").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        additionAndSubtraction.decrement();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "D").start();
    }

}

执行结果：

(2) JUC方式


class AdditionAndSubtraction2{

    private int number = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void increment() throws InterruptedException {
        try {
            lock.lock();
            //需要加锁的部分
            //1、判断
            while (number != 0){
                condition.await();
            }
            //2、干活
            number++;
            System.out.println(Thread.currentThread().getName() + "\t" +number);
            //3、通知
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void decrement() throws InterruptedException {

        try {
            lock.lock();
            //需要加锁的部分
            //1、判断
            while (number == 0){
                condition.await();
            }
            //2、干活
            number--;
            System.out.println(Thread.currentThread().getName() + "\t" + number);
            //3、通知
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
}


/**
 * 题目：现在两个线程，可以操作初始值为零的一个变量，
 * 实现一个线程对该变量加1，一个线程对该变量-1，
 * 实现交替，来10轮，变量初始值为0.
 *      1.高内聚低耦合前提下，线程操作资源类
 *      2.判断/干活/通知
 *      3.防止虚假唤醒(判断只能用while，不能用if)
 *		4.标志位
 * 知识小总结：多线程编程套路+while判断+juc
 */
public class ProducersAndConsumersTest {

    public static void main(String[] args) {

        AdditionAndSubtraction2 additionAndSubtraction2 = new AdditionAndSubtraction2();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    additionAndSubtraction2.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    additionAndSubtraction2.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    additionAndSubtraction2.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    additionAndSubtraction2.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();


    }

}

执行结果：

四、线程间定制化调用通信

package com.example.jucdemo.test;


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

class ShareResource{


    private int number = 1; //A:1,B:2,C:3,D:4
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();


    public void print5(){
        try {
            lock.lock();
            //1、判断
            while (number != 1){
                condition1.await();
            }
            //2、干活
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            //3、通知
            number = 2;
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print10(){
        try {
            lock.lock();
            //1、判断
            while (number != 2){
                condition2.await();
            }
            //2、干活
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            //3、通知
            number = 3;
            condition3.signal();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }


    public void printd15(){
        try {
            lock.lock();
            //1、判断
            while(number != 3){
                condition3.await();
            }
            //2、干活
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            //3、通知
            number = 1;
            condition1.signal();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

}


/**
 *
 * @Description:
 * 多线程之间按顺序调用，实现A->B->C
 * 三个线程启动，要求如下：
 *
 * AA打印5次，BB打印10次，CC打印15次
 * 接着
 * AA打印5次，BB打印10次，CC打印15次
 * ......来10轮
 *
 */
public class ThreadOrderAccess {

    public static void main(String[] args) {

        //资源类
        ShareResource shareResource = new ShareResource();

        //线程操作资源类
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                shareResource.print5();
            }
        }, "AA").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                shareResource.print10();
            }
        }, "BB").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                shareResource.printd15();
            }
        }, "CC").start();


    }

}

执行结果：

ad07
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC学习笔记 .md
01-31
JUC学习笔记 .md
JUC学习笔记
PaulHoldOn的博客
04-16 169
JUC
Java高并发核心编程(JUC)—线程池详细笔记
Cheney的博客
05-22 1117
线程池：一个容纳多个线程的容器，容器中的线程可以重复使用，省去了频繁创建和销毁线程对象的操作降低资源消耗，减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务提高响应速度，当任务到达时，如果有线程可以直接用，不会出现系统僵死提高线程的可管理性，如果无限制的创建线程，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控线程复用，同一个线程可以被重复使用，来处理多个任务。
Java高并发核心编程(JUC)—线程详细笔记
Cheney的博客
05-22 820
超详细Java线程详情笔记！自己整理，排版简介！
Java笔记-JUC基础
虽然但是
02-09 437
JUC
个人学习JUC代码笔记总集
07-27
个人学习的时候对JUC做的笔记，包括所有代码，学习视频是尚硅谷周阳老师的JUC，需要有一定的基础才能看懂，这是个人笔记，不一定适用于所有人，谢谢！
JUC学习笔记~~~~
03-18
JUC学习笔记，学习于狂神说JavaUp主
自学的JUC学习笔记.md
12-01
总结了个人自学的JUC学习笔记，个人主页可以查看的到。
个人学习-JUC-笔记
02-25
尚硅谷周阳老师的juc课程
尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
12-27
自己整理的多线程JUC笔记尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
JUC多线程学习笔记
m0_51028853的博客
04-06 589
多线程 一. 线程;进程;多线程 普通方法调用和多线程 程序->进程->线程 在操作系统中运行的程序就是进程,比如你的电脑可以同时打开QQ,播放器,游戏,IDEA等等. 一个进程可以有多个线程,比如视频可以同时听声音,看图像,看弹幕,看字母,等等. 说起进程就不得不说下程序,程序时指令和数据的有序集合,本身没有任何运行的涵义,是一个静态的概念,而进程是执行程序的一次执行过程,它是一个动态的概念.是系统资源分配的单位. 通常在一个进程中可以包含若干线程,当然一个进程中至少有一个线程,不然
JUC并发编程学习笔记（简单易懂）
林夕
06-14 836
非公平锁:可以插队(无参构造方法默认为非公平锁)公平锁:先来后到(有参构造方法传值true时为公平锁)/** 真正的多线程开发,公司中的开发,降低耦合型* 线程就是一个单独的资源类,没有任何附属的操作!* 1. 属性 方法* *///并发:多线程操作同一个资源类,把资源丢入线程//@FunctionalInterface 函数式接口,jkd1.8 lambda 表达式(参数)->{代码}i < 30;i++) {
JUC 并发编程学习笔记（总）
Java技术一点通
10-19 2192
JUC指的就是工具包的简称，里面的工具类可以很方便的实现多线程的开发。java.util工具包、包、分类。业务：普通的线程代码 Thread。Runnable没有返回值、效率相比Callable相对较低！
JUC总结详细笔记
最初的模样
01-26 1080
1、juc是什么 java.util.concurrent在并发编程中使用的工具类 2、进程和线程 （1）进程/线程是什么 进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。 线程：通常在一个进程中可以包含至少一个线程。线程可以利用进程所拥有的资源，在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位，由于线程比进程更小，基本上不拥
JUC笔记
wangshiqi666的博客
05-16 370
juc
【JUC】并发编程学习笔记（一）
lushixuan12345的博客
12-01 511
基础知识、Lock锁、线程间的通信、集合的线程安全
黑马juc并发编程md笔记
最新发布
09-22
黑马程序员的JUC并发教程一是关于并发编程的课程，包括了进程与线程、并行与并发、Java线程等内容。其中涵盖了创建和运行线程、线程的运行原理、线程的方法、线程状态等知识点。并发是指多个程序在同一时间段内在同...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值