2022-08-03 学习日记（23rd day）多线程--第二天

最新推荐文章于 2024-09-27 16:57:59 发布

激进的土豆

最新推荐文章于 2024-09-27 16:57:59 发布

阅读量71

点赞数 1

分类专栏： java学习日记文章标签：学习 java

本文链接：https://blog.csdn.net/weixin_49627122/article/details/126146588

版权

java学习日记专栏收录该内容

48 篇文章 2 订阅

订阅专栏

锁

synchronized多线程并发编程

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

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

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

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

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

操作共享数据的代码

共享数据：多个线程共同操作的变量，都可以充当锁

public static void main(String[] args) {
        // 同步代码块
        // 创建一个对象
        // 类对象
        // 当前实例this
        // 同步监视器
     synchronized (Ch01.class) {
            int a = 1;
        }
    }

当使用同步方法时，synchronized锁的东西是this（默认的）

关于同步方法

1.同步方法依然涉及到同步锁对象，不需要我们写出来
2.非静态的同步方法，同步锁就是this
静态的同步方法，同步监视器就是类本身

同步代码块：

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

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

同步的方式，解决线程安全的问题。

操作同步代码时，只有一个线程能够参与，其他线程等待。

相当于一个单线程的过程，效率低。

synchronized只针对于当前JVM可以解决线程安全问题。

synchronized不可以跨JVM解决问题！！！

写一个买票的例题：

class Window3 extends Thread {
    private static int ticket = 100;

    private String name;

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

    @Override
    public void run() {
        sell();
    }

    private synchronized void sell() {
        while(true) {
            if(ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(name + "卖票，剩余：" + ticket-- + "张！");
            }else {
                break;
            }
        }
    }
}
public class Ch03 {

    public static void main(String[] args) {
        Window3 w1 = new Window3("窗口一");
        Window3 w2 = new Window3("窗口二");


        w1.start();
        w2.start();
    }
}

死锁

死锁是这样一种情形：多个线程同时被阻塞，他们中的一个或者全部
都在等待某个资源的释放，由于线程无限期的阻塞，程序就不可能正常终止。

java死锁产生四个必要条件
         1.互斥使用，当资源被一个线程使用（占用），别的线程不能使用。
         2.不可抢占，资源请求者不能强制从占有者中抢夺资源，资源只能从占有者手动释放
         3.请求和保持，
         4.循环等待，存在一个等待队列。P1占有P2的资源，P2占有了P3的资源P3占有P1的资源。形成了一个等待环路。

我们的程序中要避免死锁，人为创建死锁也是比较难的。这里就不写例题了。

线程重入

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

JDK1.6以后锁升级：
        1.无锁：不加锁
        2.偏向锁：不锁锁，只有一个线程争夺时，偏向某一个线程，这个线程不加锁
        3.轻量级锁：少量线程来了之后，向尝试自旋，不挂起线程。
        4.重量级锁：排队挂起（暂停）线程。（synchronized）

挂起线程和恢复线程需要转入内核态中完成这些操作，给系统的并发性带来很大的压力。
在许多应用上共享数据的锁定状态，只会持续很短的时间，为了这段时间去挂起和恢复并不值得
我们可以让后面的线程等待一下，不要放弃处理器的执行时间。锁为了让线程等待，我们只需要让线程执行一个循环，自旋。【自旋锁】

public class Ch05 {

    private static final Object M1 = new Object();
    private static final Object M2 = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (M1) {
                synchronized (M2) {
                    synchronized (M1) {
                        synchronized (M2){
                            System.out.println("hello lock");
                        }
                    }
                }
            }
        }).start();
    }
}

Object类对多线程的支持

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

线程间的通信
比如两条线程，共同运行。
线程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方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

3、使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

4、sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

总结：

两者都可以暂停线程的执行。

sleep()方法是属于Thread类中的。而wait()方法是属于Object类中的。

Wait 通常被用于线程间交互/通信，sleep 通常被用于暂停执行。

sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。

在调用sleep()方法的过程中，线程不会释放对象锁。

而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备，获取对象锁进入运行状态。线程不会自动苏醒。

线程的退出：

使用退出标志，线程正常退出，run方法结束后线程终止，不要使用stop方法（已被弃用了）。

例子：


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();
    }
}

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();
    }
}

线程常用方法：

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()：查看当前线程是否中断