多线程初阶（2）

最新推荐文章于 2025-08-15 22:56:20 发布

2.5条悟T^T

最新推荐文章于 2025-08-15 22:56:20 发布

阅读量645

点赞数 24

CC 4.0 BY-SA版权

分类专栏： JavaEE初阶文章标签： java javaee 多线程

本文链接：https://blog.csdn.net/2301_80634989/article/details/147724523

JavaEE初阶专栏收录该内容

6 篇文章

订阅专栏

说到多线程编程，一定少不了线程安全这个话题。我们前面了解了线程的原理以及线程与进程的关系。线程之间共享资源，这就代表了在多线程编程中一定会产生冲突，所以我们需要在敲代码时保证线程安全，避免这样的问题发生。

我们先看一个代码案例

public class Test10 {
    static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                count++;
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                count++;
            }
        });

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

        //保证线程都执行完
        Thread.sleep(1000);

        System.out.println(count);
    }
}

在我们看来，运行的结果应该是100000，但是事实并非如此。

运行结果：

1.随机调度

count++;

这段代码是看似是一个指令，但实际上是分步执行的。

分为三步的：

1.读取数据

2.修改数据

3.放回内存

在执行过程中，CPU资源是随时会被调度走的，也就是说，如果执行到了读取内存，有可能会被立刻调度走的。这就是所谓的随机调度。

为了解释上面的案例可以画一个时间线：

这也就是造成上面现象的原因之一。

那我们应该如何解决呢？

解决方案1：

利用join方法，在t1执行完后再执行t2，这样虽然能解决问题，但是失去了并发执行的意义，串行执行的效率也比较低。

public class Test10 {
    static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                count++;
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                count++;
            }
        });

        t1.start();
        t1.join();
        t2.start();
        t2.join();

        //保证线程都执行完
        Thread.sleep(1000);

        System.out.println(count);
    }
}

2.锁（synchronized）

对于解决上述的线程问题，引入了锁这一概念。

锁是什么，我们可以举个具体的例子来了解一下：

我们可以把锁看成家里的锁，当家里没人时，门是从外面锁上的，这时拥有钥匙的人就可以打开锁并进去执行任务，但为了在执行任务的时候是安全的，所以会从里面锁上，这时外面的人就算有钥匙也打不开门，当里面的人执行完任务的出来后还会把门带上，这时外面拥有钥匙的人就可以开门进去了。这其实就是锁是如何解决线程安全问题的类似原理。

public class Test10 {
    static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                synchronized (locker) {
                    count++;
                }
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                synchronized (locker) {
                    count++;
                }
            }
        });

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

//        t1.start();
//        t1.join();
//        t2.start();
//        t2.join();

        //保证线程都执行完
        Thread.sleep(1000);

        System.out.println(count);
    }
}

运行结果：

我们先了解一下使用锁的格式：

synchronized(锁对象){
    
}

这里的锁对象可以是任意引用类型的对象，但要保证在解决同一个非原子问题时是同一个对象。

synchronized的使用方法除了上述格式以外，还能用来修饰方法：

这里的锁对象是this。

class Counter{
    int count = 0;

    public synchronized void addCount(){
        count++;
    }
}

public class Test11 {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Counter counter = new Counter();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                counter.addCount();
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                counter.addCount();
            }
        });
        t1.start();
        t2.start();

        Thread.sleep(100);
        System.out.println(counter.count);
    }
}

运行结果：

其实这样的解决方法也就是将局部的任务给串行化，只不过比直接将整个线程串行化来的含蓄，性能降低的少。

可重入

在Java中synchronized具有可重入的特点。

synchronized (locker) {
                    synchronized (locker) {
                        count++;
                    }
                }

我们知道，锁是具有互斥性的，也就是在上锁后是需要解锁后才能让下一个拥有锁对象的任务执行，那上面这段代码就会形成一个死锁的现象，当进入第一个锁后，会遇到第二个锁，但是想要进入第二个synchronized是需要从第一个synchronized中出来的，但是要想从第一个synchronized中出来就需要进入第二个synchronized，所以这就形成了一个死循环，可以叫死锁。

Java的开发人员为了解决这一问题就赋予了synchronized可重入这一属性，也就是在上述情况下不会出现死锁的现象，Java会自动识别出来。

如果有很多层synchronized嵌套的话，当第一次进入的synchronized结束时，这把锁才会解开。

死锁

上面讲可重入性的时候讲到了死锁这一概念，这里就详细讲讲死锁。

造成死锁有三种情况：

1.一个线程同一个锁加多次，这也是讲述可重入性时举的例子。

2.N个线程，M把锁。

public class Test12 {
    public static void main(String[] args) {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker1){
                try {
                    System.out.println("t1获取了locker1！");
                    //确保t2先拿到locker2
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker2){
                    System.out.println("t1获取了两把锁！");
                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (locker2){
                try {
                    System.out.println("t2获取了locker2！");
                    //确保线程t1先拿到locker1
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker1){
                    System.out.println("t2获取了两把锁！");
                }
            }
        });
        t1.start();
        t2.start();

    }
}

运行结果：

进程并没有结束，使用jconsole查看线程状态，发现是BLOCKED，也就锁造成的无上限的阻塞等待。这是因为在线程t1拿到locker1和t2拿到locker2的情况下，t1要想拿到locker2就必须要让t2解锁，而t2要想解锁，就需要拿到locker1，但是locker1在t1手中，所以就形成了死循环，也就构成了死锁。

3.哲学家就餐问题

假设有七个哲学家围着一个桌子吃饭，每两个人中间放一根筷子，这样的话当一个人用筷子吃饭的时候，他两侧的人都没法用餐。

在一种极端情况下，每个哲学家都拿起他左手边的筷子，这样所有哲学家都在等待对方放下筷子，就形成了死锁。

public class Test13 {
    public static void main(String[] args) {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Object locker3 = new Object();
        Object locker4 = new Object();
        Object locker5 = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker1){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker5){

                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (locker2){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker1){

                }
            }
        });
        Thread t3 = new Thread(()->{
            synchronized (locker3){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker2){

                }
            }
        });
        Thread t4 = new Thread(()->{
            synchronized (locker4){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker3){

                }
            }
        });
        Thread t5 = new Thread(()->{
            synchronized (locker5){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker4){

                }
            }
        });
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

各线程状态：

解决方案：

1.对筷子按顺序进行编号，先拿到左右小的编号的筷子，拿到后再拿左右大的编号的筷子。

刚开始1号先吃到饭，吃完后放下1号和7号筷子，2号拿到1号筷子，7号拿到7号筷子，7号可以就餐，以此类推，所有人都可以完成就餐。

public class Test13 {
    public static void main(String[] args) {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Object locker3 = new Object();
        Object locker4 = new Object();
        Object locker5 = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker1){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker5){

                }
            }
        });
        Thread t2 = new Thread(()->{
            //保证t1先拿到locker1，如果t2先拿到locker1，还是会形成死锁
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (locker1){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker2){

                }
            }
        });
        Thread t3 = new Thread(()->{
            synchronized (locker2){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker3){

                }
            }
        });
        Thread t4 = new Thread(()->{
            synchronized (locker3){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker4){

                }
            }
        });
        Thread t5 = new Thread(()->{
            synchronized (locker4){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker5){

                }
            }
        });
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

运行结果：

4.死锁总结：

造成死锁的原因：

1.锁具有互斥性（锁的基本特性）

当一个锁被一个线程获取之后，当别的线程想要获取这个锁的时候，会线程阻塞。

2.锁不可抢占（锁的基本特性）

当这个锁已经被获取时，别的线程是不能强行抢占这个锁的，必须等待获取。

3.请求和保持

当一个线程已经有至少一个锁的时候，尝试获取别的锁遇到阻塞，这时候该线程也不会放弃原来的锁。

4.循环等待

线程1等待线程2，线程2等待线程3，线程3等待线程4，线程4等待线程5，线程5等待线程1，这样就产生了死循环。

解决方案：

1.把嵌套的锁改为并列的锁。（基于N个线程，M把锁的代码例子）

public class Test14 {
    public static void main(String[] args) {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker1){
                System.out.println("t1拿到locker1！");
//                try {
//                    Thread.sleep(100);
//                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
//                }
            }
            synchronized (locker2){
                System.out.println("t1拿到locker2！");
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (locker2){
                System.out.println("t2拿到locker2！");
//                try {
//                    Thread.sleep(100);
//                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
//                }
            }
            synchronized (locker1){
                System.out.println("t2拿到locker1！");
            }
        });
        t1.start();
        t2.start();
    }
}

运行结果：

2.规定加锁顺序编号递增/递减（基于哲学家就餐问题）

代码案例在上述哲学家就餐问题中的Test13.

3.java标准库中的线程安全类：

StringBuffer，Hashtable，Vector，ConcurrentHashMap，String。。。。。。

前三个不推荐使用。

不安全类：
StringBuilder，ArrayList，LinkedList，HashMap，TreeMap，HashSet，TreeSet。

以StringBuffer为例，查看标准库中的代码，发现其内部是由简单加synchronized实现的，当面对比较复杂的情况时，很有可能会出现bug~~

4.wait/notify

在有些情况下我们需要让某个线程处于阻塞状态，在完成某些任务后再进行唤醒。

注意在调用wait/notify时必须实在synchronized的代码块中，并且必须是相同的锁对象才行。

wait下的线程状态：WAITING

public class Test16 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker) {
                System.out.println("线程t1wait......");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程t1被唤醒！");
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (locker) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("t2线程尝试唤醒t1......");
                locker.notify();
            }
        });
        t1.start();
        t2.start();
    }
}

运行结果：

、

在线程wait期间，该线程是主动放弃了CPU资源的，是解锁状态，暂时不会参与锁竞争。

这种情况下，当使用notify唤醒时只能唤醒其中一个，并且是随机的，这就有很大的不确定性在里面，所以java标准库中还提供了notifyAll方法，能够唤醒所有相同锁对象的wait。

对于notify是随即唤醒这一点还有可能会造成线程饿死，所谓线程饿死也就是某个线程长时间没有吃到CPU的资源。

public class Test17 {
    public static void main(String[] args) {
        Object l1 = new Object();
        Thread t1 = new Thread(()->{
            synchronized (l1){
                try {
                    l1.wait();
                    System.out.println("t1被唤醒！");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (l1){
                try {
                    l1.wait();
                    System.out.println("t2被唤醒！");
                }    catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t3 = new Thread(()->{
            synchronized (l1){
                try {
                    l1.wait();
                    System.out.println("t3被唤醒！");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t4 = new Thread(()->{
            System.out.println("输入任意内容唤醒所有线程：");
            Scanner sc = new Scanner(System.in);
            sc.next();
            synchronized (l1){
                l1.notifyAll();
            }
        });

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

运行结果：