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

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

Java 多线程 锁

学习重点

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

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

学习内容

Java 多线程 锁

synchronized多线程并发编程

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

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

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

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

修饰方法:

锁的目标

  • 实例方法:调用该方法的实例
  • 静态方法:类对象

修饰代码块:

锁的目标

  • this:调用该方法的实例对象
  • 类对象:类对象

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

public class Ch01 {

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

        }
    }
}

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

关于同步方法:

  • 同步方法依然涉及到同步锁对象,不需要我们写出来
  • 非静态的同步方法,同步锁就是this

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

同步代码块:

  • 选好同步监视器(锁),推荐使用类对象,第三方对象,this
  • 在实现接口创建的线程类中,同步代码块不可以用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死锁产生四个必要条件

  • 互斥使用:当资源被一个线程使用(占用),别的线程不能使用
  • 不可抢占:资源请求者不能强制从占有者抢夺资源,资源只能从占有者手动释放
  • 请求和保持
  • 虚幻等待:存在一个等待的队列。P1占有了P2的资源,P2占有了P3的资源,P3占有P1的资源。形成了一个等待环路

线程重入

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

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

  • 无锁:不加锁
  • 偏向锁:不锁锁,只有一个线程争夺是,偏向后一个线程,这个线程不加锁
  • 轻量级锁:少量线程来了,先尝试自旋,不过挂起线程
  • 重量级锁:排队挂起(暂停)线程(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("--------------------------------------------------");
    }
}

方法总结:

  • Thread的两个静态方法:
    sleep释放CPU资源,但是不会释放锁
    yield方法释放CPU执行权,保留了CPU的执行资格,不常用。
  • join方法,yield出让了执行权,join就加入进来。
  • wait:释放CPU资源,释放锁
    notify:唤醒等待中的线程
    notifyAll:唤醒等待中的所有线程

面试题:sleep和wait的区别?

  • 出处:
    sleep出自Thread,wait出自Object
  • 锁的控制:
    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类对多线程的支持

均为非静态:

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

Thread类中的方法

  • start():启动当前线程;执行run方法
  • run():
  • currentThread():静态方法,获取当前正在执行的线程
  • getId():返回此线程的唯一标识
  • setName(String):设置当前线程的name
  • getName():获取当前线程的name
  • getPriority():获取当前线程的优先级
  • setPriority(int):设置当前线程的优先级
  • getState():获取当前线程的生命周期
  • interrupt():中断线程的执行
  • 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());
    }
}
————————

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

Java 多线程 锁

学习重点

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

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

学习内容

Java 多线程 锁

synchronized多线程并发编程

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

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

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

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

修饰方法:

锁的目标

  • 实例方法:调用该方法的实例
  • 静态方法:类对象

修饰代码块:

锁的目标

  • this:调用该方法的实例对象
  • 类对象:类对象

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

public class Ch01 {

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

        }
    }
}

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

关于同步方法:

  • 同步方法依然涉及到同步锁对象,不需要我们写出来
  • 非静态的同步方法,同步锁就是this

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

同步代码块:

  • 选好同步监视器(锁),推荐使用类对象,第三方对象,this
  • 在实现接口创建的线程类中,同步代码块不可以用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死锁产生四个必要条件

  • 互斥使用:当资源被一个线程使用(占用),别的线程不能使用
  • 不可抢占:资源请求者不能强制从占有者抢夺资源,资源只能从占有者手动释放
  • 请求和保持
  • 虚幻等待:存在一个等待的队列。P1占有了P2的资源,P2占有了P3的资源,P3占有P1的资源。形成了一个等待环路

线程重入

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

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

  • 无锁:不加锁
  • 偏向锁:不锁锁,只有一个线程争夺是,偏向后一个线程,这个线程不加锁
  • 轻量级锁:少量线程来了,先尝试自旋,不过挂起线程
  • 重量级锁:排队挂起(暂停)线程(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("--------------------------------------------------");
    }
}

方法总结:

  • Thread的两个静态方法:
    sleep释放CPU资源,但是不会释放锁
    yield方法释放CPU执行权,保留了CPU的执行资格,不常用。
  • join方法,yield出让了执行权,join就加入进来。
  • wait:释放CPU资源,释放锁
    notify:唤醒等待中的线程
    notifyAll:唤醒等待中的所有线程

面试题:sleep和wait的区别?

  • 出处:
    sleep出自Thread,wait出自Object
  • 锁的控制:
    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类对多线程的支持

均为非静态:

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

Thread类中的方法

  • start():启动当前线程;执行run方法
  • run():
  • currentThread():静态方法,获取当前正在执行的线程
  • getId():返回此线程的唯一标识
  • setName(String):设置当前线程的name
  • getName():获取当前线程的name
  • getPriority():获取当前线程的优先级
  • setPriority(int):设置当前线程的优先级
  • getState():获取当前线程的生命周期
  • interrupt():中断线程的执行
  • 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());
    }
}