Java多线程(3)

最新推荐文章于 2024-06-11 08:56:11 发布

魚小飛

最新推荐文章于 2024-06-11 08:56:11 发布

阅读量1.1k

点赞数 16

分类专栏：鱼小飞代码之旅文章标签： java java-ee

本文链接：https://blog.csdn.net/m0_58154870/article/details/127565523

版权

鱼小飞代码之旅专栏收录该内容

40 篇文章 1 订阅

订阅专栏

1.线程状态回顾

NEW:Thread对象有了,内核中还没有该线程
TERMINATED:内核中的线程没了,Thread对象还在
RUNNABLE:就绪状态(和运行)
TIMED_WAITING:因为sleep进入阻塞状态
BLOCKED:因为等待锁引入了阻塞状态
WAITING:因为wait进入了阻塞状态

2.Java 标准库中的线程安全类

Java 标准库中很多都是线程不安全的.这些类可能会涉及到多线程修改共享数据,又没有任何加锁措施.

对于这些类,在多线程中使用的时候要注意安全问题,合理运用synchronized,和良好的代码逻辑来避免线程安全问题.

ArrayList
LinkedList
HashMap
TreeMap
HashSet
TreeSet
StringBuilder

还有一些是线程安全的. 使用了一些锁机制来控制.

虽然这些类是线程安全的,但是有的是不推荐使用的,因为这些类的底层虽然加了synchronized来保证安全,但是他们属于无脑加synchronized锁(每个方法都给加上锁).所以会大大降低效率,在工作中建议使用不安全的类,自己按照逻辑对不安全的代码加锁就好.

Vector (不推荐使用)
HashTable (不推荐使用)
ConcurrentHashMap
StringBuffer

3.wait 和 notify

由于线程之间是抢占式执行的,因此线程之间执行的先后顺序难以预知.

但是实际开发中有时候我们希望合理的协调多个线程之间的执行先后顺序.这时候就要用到我们的 wait 和 notify 方法了

首先需要知道的是: wait, notify, notifyAll 都是 Object 类的方法.所以每个对象都有该方法.

wait() / wait(long timeout): 让当前线程进入等待状态.
notify() / notifyAll(): 唤醒在当前对象上等待的线程.

wait

先观察代码

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        synchronized (object) {
            System.out.println("等待中");
            object.wait();
            System.out.println("等待结束");
        }
    }
}

wait 要搭配 synchronized 来使用. 脱离 synchronized 使用 wait 会直接抛出异常.
wait 会使当前执行代码的线程进行等待. (把线程放到等待队列中)
wait 还会释放当前线程占用的锁(synchronized的锁)
满足一定条件时被唤醒后, 重新尝试获取这个锁(synchronized).

notify

方法notify()也要在同步方法或同步块中调用,该方法是用来通知那些可能等待该对象的对象锁的其它线程,对其发出通知notify,并使它们重新获取该对象的对象锁.
如果有多个线程等待,则有线程调度器随机挑选出一个呈 wait 状态的线程.(并没有 “先来后到”)
在notify()方法后,当前线程不会马上释放该对象锁,要等到执行notify()方法的线程将程序执行完,也就是退出同步代码块之后才会释放对象锁.

观察 wait 和 notify 的配合使用

public class Test {
    private static Object locker;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            synchronized(locker){
                System.out.println("wait:前");
                try {
                    locker.wait();
                    //调用等待方法,等待notify方法唤醒.
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("wait:后");
            }
        });
        t1.start();

        Thread.sleep(3000);

        Thread t2 = new Thread(() -> {
            synchronized(locker){
                System.out.println("notify:前");
                locker.notify();
                System.out.println("notify:后");
            }
        });
        t2.start();
    }
}

notify 和 notifyAll 的区别

当有多个线程对同一个对象wait的时候

在代码中调用notify后,就是随机唤醒一个线程.等待notify的synchronized代码块执行完之后释放锁.让唤醒的线程获取锁.
如果调用的是notifyAll,就是将等待在该锁对象的锁全部唤醒.等待notifyAll的synchronized代码块执行完之后释放锁,让他们重新去竞争锁资源.

可以看出notify和notifyAll的最终结果都是使一个线程获取到锁资源.所以一般都是使用notify方法.

死锁

所谓死锁,是指多个进程在运行过程中因争夺资源而造成的一种僵局,当进程处于这种僵持状态时,若无外力作用,它们都将无法再向前推进.

例如如下代码.

class Counter {//死锁
    public int count = 0;
    
    synchronized void increase() {//死锁
        synchronized (this) {
            count++;
        }
    }
}