JUC详解

最新推荐文章于 2024-08-04 11:07:52 发布

程序员之窝

最新推荐文章于 2024-08-04 11:07:52 发布

阅读量1.8w

点赞数 27

文章标签： java

本文链接：https://blog.csdn.net/weixin_42998267/article/details/105173705

版权

1.什么是JUC(面试高频)

说白了就是这三个包
java.util工具包、包、分类
业务：普通的线程代码 Thread
Runnable 没有返回值、效率相比于Callable相对较低

2.线程和进程

进程：一个程序，QQ.exe Music.exe 程序的集合；
一个进程往往可以包含多个线程，至少包含一个！

java默认有几个线程？2个线程 main线程、GC线程

线程：开了一个进程Typora，写字，自动保存（线程负责的）
对于Java创建线程方式：Thread、Runnable、Callable

Java真的可以开启线程吗？开不了，用native本地方法调用底层的C++开启的！java无法操作硬件！

并发编程：并发、并行
并发(多线程操作同一个资源)

CPU一核，模拟出来多条线程，天下武功，唯快不破，快速交替制造出的假象！

并行(多个人一起行走)

CPU多核，多个线程可以同时执行；线程池

    public static void main(String[] args) {
   
//        获取cpu的核数
//        CPU密集型，IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }

并发编程的本质：充分利用CPU的资源
所有的公司都很看重！
企业，挣钱=>提高效率，裁员，找一个厉害的人顶替三个不怎么样的人;
人员(减)、技术成本(高)

线程有几种状态？

6种
附源码

public enum State {
   
        /**
         * 新生
         */
        NEW,

        /**
         * 运行
         */
        RUNNABLE,

        /**
         * 阻塞
         */
        BLOCKED,

        /**
         * 等待，死死的等
         */
        WAITING,

        /**
         * 超时等待
         */
        TIMED_WAITING,

        /**
         * 终止
         */
        TERMINATED;
    }

wait/sleep区别

来自不同的类
wait=>Object
sleep=>Thread
关于锁的释放
wait会释放锁，sleep睡觉了，抱着锁，不会释放。
使用的范围是不同的
wait：必须在同步代码块中
sleep：可以在任何地方睡
是否需要捕获异常
wait：不需要捕获异常
sleep：需要捕获异常

3.Lock锁（重点）

传统使用synchronized

package com.hzy.demo1;
//基本的卖票例子

import jdk.internal.org.objectweb.asm.Handle;

import java.util.HashMap;
import java.util.Map;

/**
 * 真正的多线程开发，公司中的开发
 * 线程就是一个单独的资源类，没有任何附属操作
 * */
public class SaleTicketDemo01 {
   
    public static void main(String[] args) {
   
//  并发：多线程操作同一个资源类，把资源类丢入线程
        Ticket ticket=new Ticket();
//        @FunctionalInterface函数式接口
        new Thread(()->{
   
            for (int i = 1; i < 50; i++) {
   
                ticket.sale(i);
            }
        },"A").start();
        new Thread(()->{
   
            for (int i = 1; i < 50; i++) {
   
                ticket.sale(i);
            }
        },"B").start();
        new Thread(()->{
   
            for (int i = 1; i < 50; i++) {
   
                ticket.sale(i);
            }
        },"C").start();
    }
}
//资源类 oop思想
class Ticket{
   
    int number=50;
//    synchronized本质：队列，锁
    public synchronized void sale(int i){
   
        if(this.number>0){
   
            System.out.println(Thread.currentThread().getName()+"卖出了"+i+"张票，剩余"+(number--)+"张票");
        }
    }
}

在这里插入图片描述
公平锁：十分公平，可以先来后到
非公平锁：十分不公平，可以插队（默认）

package com.hzy.demo1;
//基本的卖票例子

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

/**
 * 真正的多线程开发，公司中的开发
 * 线程就是一个单独的资源类，没有任何附属操作
 * */
public class SaleTicketDemo02 {
   
    public static void main(String[] args) {
   
        //  并发：多线程操作同一个资源类，把资源类丢入线程
        Ticket2 ticket2=new Ticket2();
//        @FunctionalInterface函数式接口
        new Thread(()->{
   for (int i = 1; i < 50; i++) ticket2.sale(i);},"A").start();
        new Thread(()->{
   for (int i = 1; i < 50; i++) ticket2.sale(i);},"B").start();
        new Thread(()->{
   for (int i = 1; i < 50; i++) ticket2.sale(i);},"C").start();
    }
}

//资源类 oop思想
class Ticket2{
   
    int number=50;
    Lock lock=new ReentrantLock();
//    synchronized本质：队列，锁
    public void sale(int i){
   
        lock.lock();
        try {
   
            //业务代码
            if(number>0){
   
                System.out.println(Thread.currentThread().getName()+"卖出了"+i+"张票，剩余"+(number--)+"张票");
            }
        } catch (Exception e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }
    }
}

Synchronized和Lock的区别

Synchronized内置的Java关键字，Lock是一个Java类
Synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁
Synchronized会自动释放锁，Lock必须要手动释放锁！如果不释放锁，死锁！
Synchronized线程1(获得锁)、线程2(等待，傻傻的等)；Lock就不一定会等待下去
Synchronized可重入锁，不可以中断的，非公平；Lock，可重入锁，可以判断锁，非公平(可以自己设置)
Synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)

锁是什么，如何判断锁的是谁！

4.生产者和消费者问题

生产者和消费者问题 Synchronized版 wait notify

package com.hzy.juc.pc;

/**
 * 线程之间的通信问题：生产者和消费者的问题!等待唤醒，通知唤醒
 * 线程交替执行  A B操作同一个变量  num=0
 * A num+1
 * B num-1
 * */
public class A {
   
    public static void main(String[] args) {
   
        Data data=new Data();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.increment();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.decrement();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}
class Data{
   //数字  资源类
    private int number=0;
    //+1
    public synchronized void increment() throws InterruptedException {
   
        if(number!=0){
   
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我+1完毕了
        this.notifyAll();
    }
    //-1
    public synchronized void decrement() throws InterruptedException {
   
        if(number==0){
   
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

问题所在：ABCD4个线程！就会产生虚假唤醒！

在这里插入图片描述 if改为while判断就可以解决虚假唤醒问题！

package com.hzy.juc.pc;

/**
 * 线程之间的通信问题：生产者和消费者的问题!等待唤醒，通知唤醒
 * 线程交替执行  A B操作同一个变量  num=0
 * A num+1
 * B num-1
 * */
public class A {
   
    public static void main(String[] args) {
   
        Data data=new Data();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.increment();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.decrement();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.increment();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.decrement();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}
class Data{
   //数字  资源类
    private int number=0;
    //+1
    public synchronized void increment() throws InterruptedException {
   
        while (number!=0){
   
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我+1完毕了
        this.notifyAll();
    }
    //-1
    public synchronized void decrement() throws InterruptedException {
   
        while (number==0){
   
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

JUC版的生产者和消费者问题

在这里插入图片描述

package com.hzy.juc.pc;

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

public class B {
   
    public static void main(String[] args) {
   
        Data2 data=new Data2();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.increment();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.decrement();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.increment();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.decrement();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}
class Data2{
   //数字  资源类
    private int number=0;
    //+1
    Lock lock=new ReentrantLock();
    Condition condition=lock.newCondition();
    public void increment() throws InterruptedException {
   
        lock.lock();
        try {
   
            while (number!=0){
   
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，我+1完毕了
            condition.signalAll();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }
    }
    //-1
    public synchronized void decrement() throws InterruptedException {
   
        lock.lock();
        try {
   
            while (number==0){
   
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，我-1完毕了
            condition.signalAll();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }
    }
}

任何一个新的技术，绝对不是仅仅只是覆盖原来的技术，优势和补充！

Condition 精准的通知和唤醒线程

package com.hzy.juc.pc;

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

public class C {
   
    public static void main(String[] args) {
   
        Data3 data3=new Data3();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                data3.printC();
            }
        },"C").start();
    }
}
class Data3{
   

    private Lock lock

最低0.47元/天解锁文章

程序员之窝

关注

27
点赞
踩
198

收藏

觉得还不错? 一键收藏
1
评论
JUC详解

1.什么是JUC(面试高频)java.util工具包、包、分类业务：普通的线程代码 ThreadRunnable 没有返回值、效率相比于Callable相对较低2.线程和进程进程：一个程序，QQ.exe Music.exe 程序的集合；一个进程往往可以包含多个线程，至少包含一个！java默认有几个线程？2个线程 main线程、GC线程线程：开了一个进程Typora，写字，自动...
复制链接

扫一扫