20220803 第五小组 罗大禹 学习笔记

20220803 第五小组 罗大禹 学习笔记

Java 多线程 锁

学习重点

1.synchronized多线程并发编程
2.线程间的通信

学习内容

Java 多线程 锁

synchronized多线程并发编程

​ 重量级锁。在JDK1.6对synchronized进行了优化

​ JDK1.6为了减少锁和释放锁带来的性能的消耗，引入了偏向锁和轻量级锁

synchronized有三种方式来加锁分别是：

1. 修饰成员方法：当前实例加锁，进入同步代码前要获取当前实例的锁
2. 静态方法：作用于当前类对象加锁，进入同步代码前要获得的当前类对象的锁
3. 代码块：指定该加锁对象，对给定的对象加锁，进入同步代码块之前要获得给定对象的锁

修饰方法：

锁的目标

1. 实例方法：调用该方法的实例
2. 静态方法：类对象

修饰代码块：

锁的目标

1. this：调用该方法的实例对象
2. 类对象：类对象

操作共享数据的代码
共享数据:多个线程共同操作的变量,都可以充当锁

public class Ch01 {

    public static void main(String[] args) {
        synchronized(Ch01.class/*同步监视器*/) {

        }
    }
}

当使用同步锁时,synchronized锁的东西是this(默认的)

关于同步方法:

1. 同步方法依然涉及到同步锁对象,不需要我们写出来

2. 非静态的同步方法,同步锁就是this

静态的同步方法,同步监视器就是类本身

同步代码块:

1. 选好同步监视器(锁)，推荐使用类对象,第三方对象,this

2. 在实现接口创建的线程类中,同步代码块不可以用this来充当同步锁

​ 同步的目的是为了解决线程安全的问题

​ 操作同步代码块时,只有一个线程能够参与,其他线程等待，相当于一个单线程的过程,效率低。

​ synchronized支持针对于当前JVM可以解决线程安全的问题

​ synchronized是不能跨JVM解决问题的!!!

举例说明：

class Window1 extends Thread {

    private static int ticket = 100;
    private String name;

    public Window1() {
    }

    public Window1(String name) {
        this.name = name;
    }


    @Override
    public void run() {
        sell();
    }
    public synchronized void sell() {
        while(true){
            if (ticket>0){
                try {
                    Thread.sleep(1);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println(name+"卖票,剩余:"+ --ticket +"张!");
            }else {
                break;
            }
        }
    }
}

public class Ch03 {

    public static void main(String[] args) {
        Window1 window1 = new Window1("窗口一");
        Window1 window2 = new Window1("窗口二");
        window1.start();
        window2.start();
    }
}

死锁

死锁:多线程同时被阻塞,他们中的一个或者多个都在等待某个资源的的释放,由于线程无限期阻塞,程序就不可能正常终止

Java死锁产生四个必要条件

1. 互斥使用：当资源被一个线程使用(占用),别的线程不能使用

2. 不可抢占：资源请求者不能强制从占有者抢夺资源,资源只能从占有者手动释放

3. 请求和保持

4. 虚幻等待：存在一个等待的队列。P1占有了P2的资源,P2占有了P3的资源，P3占有P1的资源。形成了一个等待环路

线程重入

任意线程再拿到锁之后,再次获取该锁不会被改锁锁阻碍，线程是不会被自己锁死,这就叫线程重入,synchronized可重入锁

JDK1.6之后,进行了锁的升级

1. 无锁:不加锁

2. 偏向锁:不锁锁,只有一个线程争夺是,偏向后一个线程,这个线程不加锁

3. 轻量级锁:少量线程来了,先尝试自旋,不过挂起线程

4. 重量级锁:排队挂起(暂停)线程(synchronized)

​ 挂起线程和恢复线程需要转入内核态中完成这些操作,会给系统的并发性带来很大的压力

​ 在许多应用上共享数据的锁定,只会持续很短的时间,为了这段时间去挂起和恢复并不值得

​ 我们可以让后面的线程等待一下,不要放弃处理器的执行时间,锁为了让线程等待,我们只需要让线程执行一个循环,自旋【自旋锁】

线程间的通信

比如两条线程，共同运行。

线程A如果先走，线程B就要等待。等待线程A走完，唤醒线程B，线程B再走

public class Ch01 {

    private static int num = 10;

    private static final Object OBJ = new Object();

    public static void plus(int code,int i) {
        synchronized (OBJ) {
            if(num >= 10){
                // 唤醒其他等待的线程
//               OBJ.notify();
                // 唤醒所有等待的线程
                OBJ.notifyAll();
            }
            System.out.println("这是线程" + code + "->" + ++num + "->" + i);
        }
    }
    public static void sub(int code,int i) {
        synchronized (OBJ) {
            if(num <= 0){
                try {
                    // 减法上来就是等待的状态
                    OBJ.wait(200);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("这是线程" + code + "->" + --num + "->" + i);
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0;; i++) {
                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                sub(1,i);
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0;; i++) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                plus(2,i);
            }
        });
        t1.start();
        t2.start();

        System.out.println("--------------------------------------------------");
    }
}

方法总结：

1. Thread的两个静态方法：

   sleep释放CPU资源，但是不会释放锁

   yield方法释放CPU执行权，保留了CPU的执行资格，不常用。

2. join方法，yield出让了执行权，join就加入进来。

3. wait：释放CPU资源，释放锁

   notify：唤醒等待中的线程

   notifyAll：唤醒等待中的所有线程

面试题：sleep和wait的区别？

1. 出处:

   sleep出自Thread,wait出自Object

2. 锁的控制:

   sleep释放CPU资源,但是不会释放锁
   wait释放CPU资源,也会释放锁

案例：生产者与消费者模型

两条线程，一条线程生产产品，另一条线程消费产品

思路：

​ 这两条线程，初始状态是什么情况？

电脑工厂，生产电脑是需要时间。生产完毕100台电脑。

​ 唤醒这些等待的消费者。等待。唤醒工厂，继续生产

消费者，等待，被唤醒，100台电脑都卖出去了，等待

class Factory implements Runnable {

    @Override
    public void run() {

        synchronized (Ch02.OBJ){
            while(true){
                // 生产电脑
                System.out.println("工厂生产电脑，已经生产了：" +  ++Ch02.count + "台！");
                if(Ch02.count >= 100) {
                    super.notifyAll();
                    try {
                        wait();
                    } catch (InterruptedException e) {

                    }
                }
            }
        }
    }
}

class Consumer implements Runnable {

    @Override
    public void run() {
        synchronized (Ch02.OBJ){
            while(true){

                if(Ch02.count <= 0){
                    try {
                        super.wait();
                    } catch (InterruptedException e) {

                    }
                    notifyAll();
                }
                if(Ch02.count >= 0){
                    // 消费电脑
                    System.out.println("消费者消费了1台电脑，剩余：" + --Ch02.count + "台！");
                }
            }

        }
    }
}

public class Ch02 {

    public static final Object OBJ = new Object();

    public static int count = 0;

    public static void main(String[] args) {
        Thread t1 = new Thread(new Factory());
        Thread t2 = new Thread(new Consumer());

        t1.start();
        t2.start();
    }
}

线程的退出

1.使用退出标志，线程正常退出，run方法结束后线程终止

不要使用stop方法。它和System.exit(-1)很像

举例说明：

class MyThread extends Thread {

    volatile boolean flag = true;

    @Override
    public void run() {
        while(flag) {
            try {
                System.out.println("线程一直在运行...");
                int i = 10 / 0;
            } catch (Exception e) {
                this.stopThread();
            }
        }
    }
    public void stopThread() {
        System.out.println("线程停止运行...");
        this.flag = false;
    }
}

public class Ch03 {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

2.interrupt方法

​ 中断线程。

​ 调用interrupt方法会抛出InterruptedException异常，

​ 捕获后再做停止线程的逻辑即可。

​ 如果线程处于while(true)运行中的状态，interrupt方法无法中断线程。

举例说明

class MyThread02 extends Thread {

    private boolean flag = true;

    @Override
    public void run() {
        while(flag) {
            synchronized (this){
                try {
                    sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    this.stopThread();
                }
            }
        }
    }
    public void stopThread() {
        System.out.println("线程停止运行...");
        this.flag = false;
    }
}
public class Ch04 {

    public static void main(String[] args) {
        MyThread02 myThread02 = new MyThread02();
        myThread02.start();

        System.out.println("线程开始...");

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 中断线程的执行
        myThread02.interrupt();
    }
}

线程的常用方法：

Object类对多线程的支持

均为非静态：

1. wait()方法:
2. wait(long timeout)方法:当前线程进入等待状态
3. notify()方法：唤醒正在等待的下一个线程
4. notifyAll()方法：唤醒正在等待的所有线程

Thread类中的方法

1. start()：启动当前线程；执行run方法
2. run()：
3. currentThread()：静态方法，获取当前正在执行的线程
4. getId()：返回此线程的唯一标识
5. setName(String)：设置当前线程的name
6. getName()：获取当前线程的name
7. getPriority()：获取当前线程的优先级
8. setPriority(int)：设置当前线程的优先级
9. getState()：获取当前线程的生命周期
10. interrupt()：中断线程的执行
11. interrupted()：查看当前线程是否中断

内部类单例(完整版)

package com.jsoft.afternoon;

/**
 * 懒汉式已经过时,推荐使用内部类单例及枚举单例
 */
class Singleton {
    private static Singleton instant;

    private Singleton(){}

    public static Singleton getInstance() {
        if(instant == null) {
            synchronized (Singleton.class) {
                if(instant == null){
                    instant = new Singleton();
                }
            }
        }
        return instant;
    }

}

public class Ch06 {

    public static void main(String[] args) {
        System.out.println(Singleton.getInstance() == Singleton.getInstance());
    }
}