多线程进阶(JUC-1)准备知识

Posted 啊~小 l i

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了多线程进阶(JUC-1)准备知识相关的知识,希望对你有一定的参考价值。

多线程基础见基础1,其余可以查看我的专栏多线程

  1. 查看CPU逻辑处理器数
    System.out.println(Runtime.getRuntime().availableProcessors());
  2. Java多线程的状态
    源码如下
    public enum State {
        // 新生状态
        NEW,
        // 运行状态
        RUNNABLE,
		// 阻塞状态
        BLOCKED,
		// 等待状态(一直等待)
        WAITING,
		// 超时等待
        TIMED_WAITING,
        // 终止
        TERMINATED;
    }
  1. wait/sleep的区别
  • 来自不同的类
    wait => Object
    sleep =>Thread
  • 关于锁的释放
    wait会释放锁,sleep不会释放锁
  • 使用范围不同
    wait:必须在同步代码块中使用
    sleep:什么时候都可以用
  1. 通知其他线程准备唤醒
    this.notifyAll();
  2. 线程创建的方式
    1. 继承Thread类创建线程
    2. 实现Runnable接口创建线程

Lock锁

  • 传统的锁Synchronized
    public synchronized void test()在方法上加入synchronized
  • lock
    源码
   public ReentrantLock() {
        sync = new NonfairSync(); //NonfairSync() 非公平锁  FairSync() 公平锁
    }
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

公平锁:先来先服务
非公平锁(默认): 可插队

Lock lock = new ReentrantLock();
        lock.lock();
        // 尝试获取锁
        lock.tryLock();
        try {

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

Synchronized和Lock区别

  1. synchronized 是Java内部的关键字,Lock 是一个Java类
  2. synchronized 无法判断锁的状态,Lock 可以判断是否取到了锁
  3. synchronized 是自动释放锁,Lock需要手动释放锁(如果不释放,产生死锁)
  4. synchronized 当一个线程获得锁,如果线程被阻塞;另一个线程只能一直去等待,Lock锁不一定一直等待
  5. synchronized 可重入锁、不可中断锁、非公平锁,Lock 可重入锁、可以判断锁,非公平(默认非公平,可以设置公平锁)
  6. synchronized 适用于少量代码的同步问题,Lock 适用于锁大量的同步代码

什么是锁,怎么判断锁的是谁?

  1. ​ 在计算机科学中,锁(lock)与互斥(mutex)是一种同步机制,用于在许多线程执行时对资源的限制。
    ​ 锁通常需要硬件支持才可以有效实施。这种支持通常采用一个或多个原子指令,测试单个线程是否空闲。

synchrnoized实现传统的生产者消费者模式

package demo1.Juc;
public class demo1 {
    private int data = 0;
    public static void main(String[] args) {
        demo1 demo = new demo1();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    demo.inCr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

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

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

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


    public synchronized void inCr() throws InterruptedException {
        if (data!=0){
            this.wait();
        }
        data++;
        System.out.println(Thread.currentThread().getName()+"=>"+data);
        this.notifyAll();
    }
    public synchronized void deCr() throws InterruptedException {
        if (data==0){
            this.wait();
        }
        data--;
        System.out.println(Thread.currentThread().getName()+"=>"+data);
        this.notifyAll();
    }
}

问题:虚假唤醒
虚假唤醒:一般而言线程调用wait()方法后,需要其他线程调用notify,notifyAll方法后,线程才会从wait方法中返回, 而虚假唤醒(spurious wakeup)是指线程通过其他方式,从wait方法中返回。


解决:将if判断改为while判断

package demo1.Juc;
public class demo1 {
    private int data = 0;
    public static void main(String[] args) {
        demo1 demo = new demo1();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    demo.inCr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

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

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    demo.inCr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    demo.deCr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
    public synchronized void inCr() throws InterruptedException {
        while (data!=0){
            this.wait();
        }
        data++;
        System.out.println(Thread.currentThread().getName()+"=>"+data);
        this.notifyAll();
    }
    public synchronized void deCr() throws InterruptedException {
        while (data==0){
            this.wait();
        }
        data--;
        System.out.println(Thread.currentThread().getName()+"=>"+data);
        this.notifyAll();
    }
}

以上是关于多线程进阶(JUC-1)准备知识的主要内容,如果未能解决你的问题,请参考以下文章

Java进阶之光!2021必看-Java高级面试题总结

Java知识体系Java并发编程进阶,多线程和锁底层原理探究

[java进阶]关于多线程的知识点

Java高级部分知识总结快速进阶

多线程进阶=>JUC并发编程

多线程和多进程不可能是鸡肋!只因你还不会!最全的进阶资料!