Java基础（线程方法，线程同步，死锁）

关注

原创最新推荐文章于 2026-06-23 16:33:40 发布 339 阅读 AI 写同款· GEO 优化 ›

NWD 格式转换 STL 全流程：专业方案与迪威模型网在线转换详解在3D模型处理中，将NWD文件转换为STL格式是常见的需求，特别是在3D打印和计算机辅助制造等领域。NWD文件由Autodesk开发，主要用于建筑、工程和施工行业，包含丰富的几何图形和材质信息，但因其专有格式和大文件大小，限制了其应用范围。相比之下，STL格式广泛应用于3D打印，仅包含表面几何信息。转换NWD到STL的原因包括拓展模型应用场景和便于模型编辑。转换方法包括使用专业软件如Autodesk Navisworks配合Blender或3ds Max，或使用专门的转换工具如CADExchanger。阅读详情

线程2

1 sleep方法

线程类Thread中的sleep方法：

public static native void sleep(long millis) throws InterruptedException;

该静态方法可以让当前执行的线程暂时休眠指定的毫秒数：

public class Test {

    public static void main(String[] args) {


        Thread t1 = new Thread("t1线程"){
            @Override
            public void run() {
                try {
                    //t1线程休眠10毫秒
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
		
        //t1还没有启动，这里肯定是NEW状态
        System.out.println(t1.getState());
		
        //启动t1线程
        t1.start();
		
        //在循环期间查看t1的状态1000次
        //这里t1的状态可能是RUNNABLE，也可能是TIMED_WAITING，也可能是TERMINATED
        for (int i = 0; i < 1000; i++) {
            System.out.println(t1.getState());
        }
		
      
    }

}

//运行结果： 可以多运行几次，每次结果可能不一样
NEW
RUNNABLE
RUNNABLE
RUNNABLE
RUNNABLE
RUNNABLE
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
.....
RUNNABLE
RUNNABLE
TERMINATED
TERMINATED
TERMINATED
TERMINATED
.....

可以看出，线程执行了sleep方法后，会从RUNNABLE状态进入到TIMED_WAITING状态

这时候线程所处的是一种阻塞状态，是之前介绍过的三种阻塞情况的其中一种

这种阻塞的特点是：阻塞结束后，线程会自动回到RUNNABLE状态

此时的状态图为：

在这里插入图片描述

2 join方法

线程类Thread中的join方法：

public final synchronized void join(long millis)throws InterruptedException{
    //...
}
    
public final void join() throws InterruptedException{
    //...
}

使用join方法，可以让当前线程阻塞，等待另一个指定的线程运行结束后，当前线程才可以继续运行：

例如，使用无参的join方法

public class Test {

    public static void main(String[] args) {


        Thread t1 = new Thread("t1线程"){
            @Override
            public void run() {
                try {
                    //t1线程睡眠1秒钟
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1线程结束");
            }
        };

        Thread t2 = new Thread("t2线程"){
            @Override
            public void run() {
                try {
                    //t2线程调用t1.join方法
                    //t2线程进入阻塞状态
                    //t2线程要等到t1线程运行结束，才能恢复到RUNNABLE状态
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2线程结束");
            }
        };

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

        //让主线程休眠500毫秒，目的是为了给t1和t2点时间，让他们俩个线程进入状态
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(t2.getState());

    }

}

//运行结果：
WAITING
t1线程结束
t2线程结束

t2线程中，调用了t1对象的join方法，那么t2线程就会阻塞，等待t1线程的运行结束，t2线程才能恢复

可以看出，线程执行了join()方法后，会从RUNNABLE状态进入到WAITING状态

但是如果线程中调用的是有参数的join方法，线程所处的状态就不一样了：

例如，使用有参的join方法，其他代码和上面一样

public class Test {

    public static void main(String[] args) {


        Thread t1 = new Thread("t1线程"){
            @Override
            public void run() {
                try {
                    //t1线程睡眠1秒钟
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1线程结束");
            }
        };

        Thread t2 = new Thread("t2线程"){
            @Override
            public void run() {
                try {
                    //t2线程调用t1.join方法
                    //t2线程进入阻塞状态
                    //t2线程要等到t1线程运行结束，才能恢复到RUNNABLE状态
                    //2000表示，当前线程t2最多阻塞2秒钟，2秒钟之内t1线程没有结束，那么t2线程就自动恢复
                    t1.join(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2线程结束");
            }
        };

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

        //让主线程休眠500毫秒，目的是为了给t1和t2点时间，让他们俩个线程进入状态
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(t2.getState());

    }

}

//运行结果：
TIMED_WAITING
t1线程结束
t2线程结束

可以看出，线程执行了join(long million)方法后，会从RUNNABLE状态进入到TIMED_WAITING状态

此时的状态图为：

线程A中，调用了线程B对象的join方法，那么线程A就会进入到阻塞状态，这种阻塞又俩种情况，一种是调用了无参的join方法，那么此时线程A的状态为WAITING（无限期等待），另一种是调用了有参的join方法，那么此时线程A的状态为TIMED_WAITING（有限期等待）

线程A如果调用了sleep方法，那么线程A也会进入阻塞状态，此时线程A的状态为TIMED_WAITING

总结：

如果指定了时间，线程阻塞一定的时间后，会自动恢复到RUNNABLE状态，这种情况下，线程的状态为TIMED_WAITING（有限期等待）
如果没有指定时间，线程会一直阻塞着，直到某个条件满足时，才会自动恢复，这种情况下，线程的状态为WAITING（无限期等待）

在这种情况下，其实还有另一种方式，可以让线程从阻塞状态恢复到RUNNABLE状态，那就是调用线程的interrupt方法

3 interrupt方法

线程类Thread中的interrupt方法：

//Interrupts this thread
public void interrupt(){
    //...
}

根据上面介绍sleep方法和join方法可知，这俩个方法都会抛出InterruptedException类型的异常，说明调用sleep和join使线程进入阻塞状态的情况下，是有可能抛出InterruptedException类型的异常的。

InterruptedException异常类型指的是：线程A中，调用了线程B的interrupt方法，而此时线程B处于阻塞状态，那么此时sleep方法或者join方法就会抛出被打断的异常

public class Test {

    public static void main(String[] args) {


        Thread t1 = new Thread("t1线程"){
            @Override
            public void run() {
                try {
                    //t1线程休眠100秒
                    Thread.sleep(100000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1线程结束");
            }
        };


        t1.start();

        //让主线程休眠500毫秒，目的是为了给t1时间，让它调用sleep方法而进入阻塞状态
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //打断t1由于调用sleep方法而进入的阻塞状态
        t1.interrupt();


    }

}

//运行结果：
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at com.briup.sync.Test$1.run(Test.java:11)
t1线程结束

可以看出，本来t1线程调用了sleep方法进入了阻塞状态，需要100后才会恢复的，但是我们在主线程中调用了t1线程对象的打断方法interrupt，那么此时 Thread.sleep(100000);这句代码就会抛出被打断的异常，同时t1线程从阻塞状态恢复到RUNNABLE状态，继续执行代码，输出了t1线程结束

此时对于的流程图为：

在这里插入图片描述

interrupt方法的工作原理：

interrupt方法是通过改变线程对象中的一个标识的值（true|false），来达到打断阻塞状态的效果。

一个线程在阻塞状态下，会时刻监测这个标识的值是不是true，如果一旦发现这个值变为true，那么就抛出异常结束阻塞状态，并再把这个值改为false。

从Thread类的源码中可以看到：

interrupt方法中其实是调用了interrupt0这个本地方法，而interrupt0的注释为：Just to set the interrupt flag

public void interrupt() {
    if (this != Thread.currentThread())
        checkAccess();

    synchronized (blockerLock) {
        Interruptible b = blocker;
        if (b != null) {
            interrupt0();           // Just to set the interrupt flag
            b.interrupt(this);
            return;
        }
    }
    interrupt0();
}

private native void interrupt0();

可以看出，interrupt方法只是改变了线程对象中一个标识flag的值

查看线程对象中“打断标识”值的俩个方法：

线程类Thread中的isInterrupted方法：

public boolean isInterrupted() {
    return isInterrupted(false);
}
/**
 * Tests if some Thread has been interrupted.  The interrupted state
 * is reset or not based on the value of ClearInterrupted that is
 * passed.
 */
private native boolean isInterrupted(boolean ClearInterrupted);

注意，这个非静态方法，只是返回这个“打断标识”值，并且不会对这个值进行清除（true->false），因为所传参数ClearInterrupted的值为false

例如，默认情况下，一个线程对象中的“打断标识”值为false

public class Test {

    public static void main(String[] args) {


        Thread t1 = new Thread("t1线程"){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    //判断是否有其他线程调用了自己的interrupt方法
                    //调用类中的非静态方法：isInterrupted
                    System.out.println(this.isInterrupted());
                }
                System.out.println("t1线程结束");
            }
        };


        t1.start();

    }

}

//运行结果：
false
false
false
false
false
false
false
false
false
false
t1线程结束

无论线程是否处于阻塞状态，其他线程都可以调用这个线程的interrupt方法，因为该方法只是改变线程对象中“打断标识”值而已

例如，

public class Test {

    public static void main(String[] args) {


        Thread t1 = new Thread("t1线程"){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    //判断是否有其他线程调用了自己的interrupt方法
                    //调用类中的非静态方法：isInterrupted
                    System.out.println(this.isInterrupted());
                }
                System.out.println("t1线程结束");
            }
        };


        t1.start();

        t1.interrupt();


    }

}

//运行结果：
true
true
true
true
true
true
true
true
true
true
t1线程结束

可以看出，吊用了t1.interrupt();后，t1线程中的“打断标识”值设置为了true，可以通过线程对象中的isInterrupted方法返回这个标识的值，并且不会修改这个值，所以输出显示的一直是ture

线程类Thread中的interrupted方法：

public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}
/**
 * Tests if some Thread has been interrupted.  The interrupted state
 * is reset or not based on the value of ClearInterrupted that is
 * passed.
 */
private native boolean isInterrupted(boolean ClearInterrupted);

注意，这个静态方法，返回这个“打断标识”值，并且会对这个值进行清除（true->false），因为所传参数ClearInterrupted的值为true

例如，

public class Test {

    public static void main(String[] args) {


        Thread t1 = new Thread("t1线程"){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    //判断是否有其他线程调用了自己的interrupt方法
                    //调用类中的静态方法：interrupted
                    System.out.println(Thread.interrupted());
                }
                System.out.println("t1线程结束");
            }
        };


        t1.start();

        t1.interrupt();


    }

}

//运行结果：
true
false
false
false
false
false
false
false
false
false
t1线程结束

可以看出，第一次返回true之后，后面在调用方法查看这个“打断标识”值，都是false，因为静态方法 interrupted返回true后，会直接把这个值给清除掉。（true->false）

Thread类中的三个方法：interrupt()、isInterrupted()、interrupted()的结构关系大致如下：

public class Thread{
    
    public void interrupt() {
        //...
        interrupt0(); // Just to set the interrupt flag
    }
    private native void interrupt0();
    
    public boolean isInterrupted() {
        return isInterrupted(false);
    }
    
    public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }
    
   /**
     * Tests if some Thread has been interrupted.  The interrupted state
     * is reset or not based on the value of ClearInterrupted that is
     * passed.
     */
    private native boolean isInterrupted(boolean ClearInterrupted);
    
    public static native Thread currentThread();  
    
}

根据上面的代码结构，还有前面的一些示例以及解释，这个三个名字很像的方法，就应该容易分清楚了。

4 线程安全

JVM内存中的堆区，是一个共享的区域，是所有线程都可以访问的内存空间。

JVM内存中的栈去，是线程的私有空间，每个线程都有自己的栈区，别的先无法访问到自己栈区的数据。

我们之前编写的代码只有一个main线程，只有它自己去访问堆区中对象的数据，自然不会有什么问题。

但是在多线程环境中，如果有俩个线程并发访问堆区中一个对象中的数据，那么这个数据可能会出现和预期结果不符的情况，例如

public class Test {

    public static void main(String[] args) {

        final MyData myData = new MyData();

        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                for (int i = 0; i < 10; i++) {
                    //先给num赋值
                    myData.num = i;
                    //然后再输出num的值
                    System.out.println(name + ": " + myData.num);
                }

            }
        };

       
        t1.start();
        
    }

}

class MyData{
    int num;
}

//运行结果：
t1: 0
t1: 1
t1: 2
t1: 3
t1: 4
t1: 5
t1: 6
t1: 7
t1: 8
t1: 9

这时候，t1线程自己访问堆区中的myData对象里面的num数据值，程序的结果每次都是和预期的一样

但是，如果再加一个线程t2，同时也访问这个堆区中myData对象中的num属性值，结果可能和预期的不一样：

public class Test {

    public static void main(String[] args) {

        MyData myData = new MyData();

        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                for (int i = 0; i < 10; i++) {
                    //先给num赋值
                    myData.num = i;
                    //然后再输出num的值
                    System.out.println(name + ": " + myData.num);
                }

            }
        };

        Thread t2 = new Thread("t2"){
            @Override
            public void run() {

                for (int i = 100; i < 20000; i++) {
                    //给num赋值
                    myData.num = i;
                }

            }
        };

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



    }

}

class MyData{
    int num;
}
//运行结果：
t1: 0
t1: 11706
t1: 13766
t1: 15459
t1: 17710
t1: 19304
t1: 6
t1: 7
t1: 8
t1: 9

可以看到，每次运行的结果中，t1线程输出的num的值可能和预期都不一样

此时的内存图为：

在这里插入图片描述

注意1，t1和t2并发访问的时候，争夺CPU的时间片，运行完时间片，退出后再次争夺下一个时间片，也就是说t1和t2都是“断断续续”的运行的

注意2，在这期间，可能t1线程有一次拿到时间片运行的时候，给num赋值为1，然后时间片用完退出了，结果下次t2线程拿到了时间片，又将num的值赋成了11750，然后t1线程又拿到了时间片，本来预期的是输出1，但是结果却是输出了11750

核心的原因是，t1线程操作一下变量num，然后时间片用完退出去，t2先过来又操作了变量num，等t1线程再过来的时候，这值已经被t2线程给“偷偷”修改了，那么就出现了和预期不符的情况

总结：

如果有多个线程，它们在一段时间内，并发访问堆区中的同一个变量，并且有写入的操作，那么最终可能会出数据的结果和预期不符的情况，这种情况就是线程安全问题。

我们经常会进行这样的描述：这段代码是线程安全的，那段代码是非线程安全的。其实就是在说，这段代码在多线程并发访问的环境中，是否会出现上述情况，也就是结果和预期不符的情况。

例如，观察下面代码，是线程安全的还是非线程安全的？ t1线程每次输出的结果是否有出现和预期不符的情况？

public class Test {

    public static void main(String[] args) {


        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                //每次循环改变变量i的值
                for (int i = 0; i < 10; i++) {
                    //输出变量i的值
                    System.out.println(name + ": " + i);
                }

            }
        };

        Thread t2 = new Thread("t2"){
            @Override
            public void run() {
				//每次循环改变变量i的值
                for (int i = 100; i < 20000; i++) {

                }

            }
        };

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



    }

}

每次执行结果都是一样的，和预期的相同，因为t1和t2俩个线程根本就没访问同一个共享变量！相当于t1和t2都是各自操作各自的变量i

思考，方法中的局部变量和对象中的成员变量分别在内存中什么地方？哪些变量可能被多个线程共享？

思考，如果t1和t2先不是“争先恐后”的并发访问变量num，而是排好队一个执行完，另一个在执行，是不是就可以解决这个线程安全问题了呢？

5 线程同步

当使用多个线程访问同一个共享变量的时候，并且线程中对变量有写的操作，这时就容易出现线程安全问题。

Java中提供了线程同步的机制，来解决上述的线程安全问题。

Java中实现线程同步的方式，是给需要同步的代码进行synchronized关键字加锁。

例如，改造之前有线程安全问题的代码，给需要同步的代码使用synchronized加锁

public class Test {

    public static void main(String[] args) {

        MyData myData = new MyData();

        Thread t1 = new Thread("t1"){
            @Override
            public void run() {

                String name = Thread.currentThread().getName();
                
                synchronized (myData){
                    for (int i = 0; i < 10; i++) {
                        myData.num = i;
                        System.out.println(name + ": " + myData.num);
                    }
                }

            }
        };

        Thread t2 = new Thread("t2"){
            @Override
            public void run() {

                synchronized (myData){
                    for (int i = 100; i < 20000; i++) {
                        myData.num = i;
                    }
                }

            }
        };

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

    }

}

class MyData{
    int num;
}

现在运行这个程序，每次输出的结果都是和预期的一样：t1线程每次输出的值都是0~9

分析：

线程同步的效果，就是一段加锁的代码，每次只能有一个拿到锁的线程，才有资格去执行，没有拿到的锁的线程，只能等拿到锁的线程把代码执行完，再把锁给释放了，它才能去拿这个锁然后再运行代码。

这样以来，本来这段代码是俩线程并发访问，“争先恐后”的去执行的，现在线程同步之后，这段代码就变成了先又一个拿到的锁的先去执行，执行完了，再由另一个线程拿到锁去执行。

相当于是大家每个线程不要抢，排好队一个一个去执行，那么这时候共享的变量的值，肯定不会出现线程安全问题！

例如，synchronized修饰代码块的使用格式为：

synchronized (锁对象){
    //操作共享变量的代码，这些代码需要线程同步，否则会有线程安全问题
    //...
}

对应这样加锁的代码，如果俩个线程进行并发访问的话：

假设线程t1是第一个这段代码的线程，那么它会率先拿到这把锁，其实就是在这个锁对象中写入自己线程的信息，相当于告诉其他线程，这把锁现在是我的，你们都不能使用。
这时候t1线程拿着锁，就可以进入到加锁的代码块中，去执行代码，执行很短的一个时间片，然后退出，但是锁并不释放，也就意味着，及时下次是t2线程抢到CPU的使用权，它也无法运行代码，因为t2没有拿到锁。
就这样，t1线程开心的拿着锁，抢到CPU的执行权，抢到了就去执行，抢不到也不用担心，因为没有其他线程可以“偷偷”的执行这段代码，因为其他线程拿不到锁。
而对于t2线程来说，即使有一次抢到了CPU执行权，来到了代码面前，要执行的时候才发现，锁被t1线程拿走了，自己无法进入代码块中执行，这时候t2线程就会从运行状态进入阻塞状态，直到t1运行完，把锁释放了，t2线程才会恢复到RUNNABLE状态，抢到CPU执行权，再拿到锁，然后进入代码块中执行

注意，这时候t2线程的阻塞状态，和之前学习的调用sleep或join方法进入的阻塞不同，这种阻塞属于锁阻塞，需要等待另一个线程把锁释放了，t2线程才能恢复。如果t2线程处于这种阻塞，那么调用线程对象的getState方法返回的状态名称为：BLOCKED

例如：

public class Test {

    public static void main(String[] args) {

       Object obj = new Object();

        Thread t1 = new Thread("t1"){
            @Override
            public void run() {

                synchronized (obj){
                    try {
                        Thread.sleep(100000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        };

        Thread t2 = new Thread("t2"){
            @Override
            public void run() {

                synchronized (obj){

                }

            }
        };

        t1.start();

        //主线程休眠1秒钟，给t1线程点时间，让他先拿到锁，然后去休眠100秒
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t2.start();

        System.out.println("t1线程状态："+t1.getState());
        System.out.println("t2线程状态："+t2.getState());


    }

}
//运行结果：
t1线程状态：TIMED_WAITING
t2线程状态：BLOCKED

注意1，t1线程需要拿到锁对象obj，才能运行加锁的代码块

注意2，t2线程也需要拿到锁对象obj，才能运行加锁的代码块

注意3，锁对象obj只有一个，所以t1和t2只能有一个线程先拿到，拿到后执行代码，那么另一个就拿不到了，拿不到就阻塞，此时线程的状态为：BLOCKED

注意4，java中，任意一个对象，只要是对象，就可以用来当做，加锁代码块中的锁对象。然后让多个线程去抢这拿这把锁就可以了，此时就达到了线程同步的效果，因为拿到的锁线程能执行代码，其他拿不到的线程就不执行，并且进入阻塞状态。

此时的线程状态图为：

在这里插入图片描述

可以看出，假设t1线程拿到了锁，t2线程没拿到锁，那么t2线程就会因为锁不可用，进入到锁阻塞状态，直到t1先把加锁的代码执行完，把锁释放了，锁变的可用了，这是t2线程会自动恢复到RUNNABLE状态

注意，t1线程“拿到”锁，只是一种形象的说，就是我们之前说的引用“指向”对象一样。其实是t1线程把自己的信息写入到了锁对象中，用这种方式告诉其他线程，这个锁对象已经被我 "拿走"了

6 synchronized

通过上面线程同步例子的讲解，我们已经知道了synchronized修饰一个代码块，并指定谁是锁对象的用法，除此之外，还可以使用synchronized直接修饰一个方法，表示这个方法中的所有代码都需要线程同步。

synchronized关键字修饰非静态方法，默认使用this当做锁对象，并且不能自己另外指定

synchronized关键字修饰静态方法，默认使用当前类的Class对象当做锁对象，并且不能自己另外指定

这俩中情况的同步效果是一样的，只是锁对象不同而已

例如，

public class MyData{
    private int[] arr = new int[20];
    //当前数据可以存放的位置,也表示当前存放的元素个数
    private int current;

    //添加数据
    public void add(int num){
        String name = Thread.currentThread().getName();
        arr[current] = num;
        System.out.println(name+"线程本次写入的值为"+num+"，写入后取出的值为"+arr[current]);

        current++;
    }

}

注意，MyData类中的add方法，在多线程并发访问的环境中，是有线程安全问题的

例如，

public class Test {

    public static void main(String[] args) {

        MyData myData = new MyData();

        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    myData.add(i);
                    //计算机运行10次运行太快了，让它执行慢一些，好观察效果
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        //t2线程的名字前面加个制表符\t，打印的时候好观察
        Thread t2 = new Thread("\tt2"){
            @Override
            public void run() {
                for (int i = 10; i < 20; i++) {
                    myData.add(i);
                    //计算机运行10次运行太快了，让它执行慢一些，好观察效果
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

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


    }

}

//运行结果：
t1线程本次写入的值为0，写入后取出的值为0
	t2线程本次写入的值为10，写入后取出的值为10
	t2线程本次写入的值为11，写入后取出的值为1
t1线程本次写入的值为1，写入后取出的值为1
	t2线程本次写入的值为12，写入后取出的值为2
t1线程本次写入的值为2，写入后取出的值为2
	t2线程本次写入的值为13，写入后取出的值为3
t1线程本次写入的值为3，写入后取出的值为3
	t2线程本次写入的值为14，写入后取出的值为4
t1线程本次写入的值为4，写入后取出的值为4
t1线程本次写入的值为5，写入后取出的值为5
	t2线程本次写入的值为15，写入后取出的值为5
	t2线程本次写入的值为16，写入后取出的值为16
t1线程本次写入的值为6，写入后取出的值为16
t1线程本次写入的值为7，写入后取出的值为17
	t2线程本次写入的值为17，写入后取出的值为17
t1线程本次写入的值为8，写入后取出的值为18
	t2线程本次写入的值为18，写入后取出的值为18
t1线程本次写入的值为9，写入后取出的值为19
	t2线程本次写入的值为19，写入后取出的值为19

可以看出，在某一次add方法执行的时候，会出现写入的数据和当前的数据不一致的情况

此时，我们可以直接在add方法（非静态方法）上，添加修饰符synchronized关键字，表示给这个方法中的所有代码进行线程同步，默认使用的锁对象是this

public synchronized void add(int num){
    String name = Thread.currentThread().getName();
    arr[current] = num;
    System.out.println(name+"线程本次写入的值为"+num+"，写入后取出的值为"+arr[current]);

    current++;
}

此时，再运行代码，就不会出现之前那种线程安全问题了

该代码表示，拿到锁对象this的线程，才可以进入到add方法中执行代码，代码执行完，会释放锁，这时锁变的可用了，所有需要这把锁的线程都恢复到RUNABLE状态（它们之前在锁阻塞状态），这些线程一起重新争夺CPU执行权，谁先拿到CPU执行权，就会先过去拿到锁，进入代码去执行

注意，此时t1线程中调用add方法，争夺的锁对象this就是myData对象，t2线程中调用的add方法，争夺的锁对象this也是myData对象，所以t1和t2俩个线程争夺的是同一把锁对象，那么就能达到线程同步的效果！

所以，线程同步的效果的关键点在于，让t1和t2俩个线程去争夺同一把锁对象

思考，根据上面的例子，考虑为什么之前学习的ArrayList中的add方法是非线程安全的，而Vector中的add方法是线程安全的？

7 wait和notify

Object类中有三个方法：wait()、notify()、notifyAll

当一个对象，在线程同步的代码中，充当锁对象的时候，在synchronized同步的代码块中，就可以调用这个锁对象的这三个方法了。

三个核心点：

任何对象中都一定有这三个方法
只有对象作为锁对象的时候，才可以调用
只有在同步的代码块中，才可以调用

其他情况下，调用一个对象的这三个方法，都会报错！

synchronized关键字，虽然可以达到线程同步的效果，但是太“霸道”了，只要一个线程拿到了锁对象，那么这个线程无论是在运行状态，还是时间片用完，回到就绪状态，还是sleep休眠，这个线程都是死死的拿着这个锁对象不释放，只有这个线程把线程同步的代码执行完，才会释放锁对象让别的线程使用。

那么有没有一个方法，可以让拿到的锁的线程，即使代码没执行完，也可以把锁立即给释放了呢？

有的，这个就是wait方法

例如，

public class Test {

    public static void main(String[] args) {

        final Object obj = new Object();

        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                synchronized (obj){
                    for (int i = 0; i < 10; i++) {
                        System.out.println(name+"线程: i = "+i);
                    }
                }
            }
        };

        Thread t2 = new Thread("t2"){
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                synchronized (obj){
                    for (int j = 10; j < 20; j++) {
                        System.out.println(name+"线程: j = "+j);
                    }
                }
            }
        };

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


    }

}

t1和t2俩个线程，争夺同一把锁对象obj，所以程序的运行结果是：要么t1先拿到锁输处0_{9，然后t2再拿到锁输出10}19，要么就是t2先拿到锁输入10_{19，然后t1再拿到锁输出0}9

现在，我们希望的是t1线程中i=5的时候，先释放锁，让t2拿到锁去运行，在t2线程中，当j=15的时候，释放锁，让t1拿到锁去运行：

在代码中加入条件判断和wait方法的调用

public class Test {

    public static void main(String[] args) {

        final Object obj = new Object();

        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                synchronized (obj){
                    for (int i = 0; i < 10; i++) {
                        System.out.println(name+"线程: i = "+i);
                        if(i==5){
                            try {
                                //obj是所调用，在同步代码块中，可以调用wait方法
                                //让当前拿到锁的线程，立即释放锁
                                obj.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        };

        Thread t2 = new Thread("t2"){
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                synchronized (obj){
                    for (int j = 10; j < 20; j++) {
                        System.out.println(name+"线程: j = "+j);
                        if(j==15){
                            try {
                                //obj是所调用，在同步代码块中，可以调用wait方法
                                //让当前拿到锁的线程，立即释放锁
                                obj.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        };

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


    }

}

//运行结果：
t1线程: i = 0
t1线程: i = 1
t1线程: i = 2
t1线程: i = 3
t1线程: i = 4
t1线程: i = 5
t2线程: j = 10
t2线程: j = 11
t2线程: j = 12
t2线程: j = 13
t2线程: j = 14
t2线程: j = 15

可以看到，t1线程和t2线程都没有运行完，但是代码不运行了，JVM也没停住

这是因为，当前调用锁对象的wait方法后，当前线程释放锁，然后进入到阻塞状态，并且等待其他线程先唤醒自己，如果没有其他线程唤醒自己，那么就一直等着。所以现在的情况是，俩个线程t1和t2都是在处于阻塞状态，等待别人唤醒自己，所以程序不运行了，但是也没结束！

此时，调用t1和t2的getState方法，返回的状态为：WAITING

public class Test {

    public static void main(String[] args) {

        final Object obj = new Object();

        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                synchronized (obj){
                    for (int i = 0; i < 10; i++) {
                        System.out.println(name+"线程: i = "+i);
                        if(i==5){
                            try {
                                obj.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        };

        Thread t2 = new Thread("t2"){
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                synchronized (obj){
                    for (int j = 10; j < 20; j++) {
                        System.out.println(name+"线程: j = "+j);
                        if(j==15){
                            try {
                                obj.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        };

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

        //主线程休眠1秒钟，给t1和t2点时间，等它们调用wait方法
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("t1线程当前的状态为："+t1.getState());
        System.out.println("t2线程当前的状态为："+t2.getState());


    }

}

//运行结果：
t1线程: i = 0
t1线程: i = 1
t1线程: i = 2
t1线程: i = 3
t1线程: i = 4
t1线程: i = 5
t2线程: j = 10
t2线程: j = 11
t2线程: j = 12
t2线程: j = 13
t2线程: j = 14
t2线程: j = 15
t1线程当前的状态为：WAITING
t2线程当前的状态为：WAITING

此时线程的状态图为：

在这里插入图片描述

可以看出，此时线程调用了wait方法，释放了锁，变为阻塞状态（WAITING），并进入了等待池，等待其他线程唤醒自己或者打断自己，如果有线程调用了notify方法进行了唤醒，或者interrupt方法进行了打断，那么这个线程就会从等待池进入到锁池，而进入到锁池的线程，会时刻关注锁对象是否可用，一旦可用，这个线程就会立刻自动恢复到RUNNABLE状态。

由图可知，TIMED_WAITING、WAITING、BLOCKED都属于线程阻塞，他们共同的特点是就是线程不执行代码，也不参与CPU的争夺，除此之外，它们还有各自的特点：（重要）

阻塞1，线程运行时，调用sleep或者join方法后，进入这种阻塞，该阻塞状态可以恢复到RUNNABLE状态，条件是线程被打断了、或者指定的时间到了，或者join的线程结束了
阻塞2，线程运行时，发现锁不可用后，进入这种阻塞，该阻塞状态可以恢复到RUNNABLE状态，条件是线程需要争夺的锁对象变为可用了（别的线程把锁释放了）
阻塞3，线程运行时，调用了wait方法后，线程先释放锁后，再进入这种阻塞，该阻塞状态可以恢复到BLOCKED状态（也就是阻塞2的情况），条件是线程被打断了、或者是被别的线程唤醒了（notify方法）

理解上述的状态变化过程后，我们修改代码，加入notify方法的调用：

public class Test {

    public static void main(String[] args) {

        final Object obj = new Object();

        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                synchronized (obj){
                    for (int i = 0; i < 10; i++) {
                        System.out.println(name+"线程: i = "+i);
                        if(i==5){
                            try {
                                //在释放锁对象之前，叫醒等待池中等待obj锁对象的线程
                                //意思是告诉对方，我要释放锁了，你准备去抢把
                                obj.notify();
                                obj.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }

                    //最后在执行完所有代码之前，在叫醒一次，防止等待池中还线程在等待obj这个锁对象
                    obj.notify();

                }
            }
        };

        Thread t2 = new Thread("t2"){
            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                synchronized (obj){
                    for (int j = 10; j < 20; j++) {
                        System.out.println(name+"线程: j = "+j);
                        if(j==15){
                            try {
                                //在释放锁对象之前，叫醒等待池中等待obj锁对象的线程
                                //意思是告诉对方，我要释放锁了，你准备去抢把
                                obj.notify();
                                obj.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }

                    //最后在执行完所有代码之前，在叫醒一次，防止等待池中还线程在等待obj这个锁对象
                    obj.notify();

                }
            }
        };

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

        //主线程休眠1秒钟，给t1和t2点时间，等它们调用wait方法
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("t1线程当前的状态为："+t1.getState());
        System.out.println("t2线程当前的状态为："+t2.getState());


    }

}
//运行结果：
t1线程: i = 0
t1线程: i = 1
t1线程: i = 2
t1线程: i = 3
t1线程: i = 4
t1线程: i = 5
t2线程: j = 10
t2线程: j = 11
t2线程: j = 12
t2线程: j = 13
t2线程: j = 14
t2线程: j = 15
t1线程: i = 6
t1线程: i = 7
t1线程: i = 8
t1线程: i = 9
t2线程: j = 16
t2线程: j = 17
t2线程: j = 18
t2线程: j = 19
t1线程当前的状态为：TERMINATED
t2线程当前的状态为：TERMINATED

可以看到，此时t1和t2俩个线程都执行完了，打印输出的结果也符合我们的预期

锁对象.notify()，该方法可以在等待池中，随机唤醒一个等待指定锁对象的线程，使得这个线程进入到锁池中，而进入到锁池的线程，一旦发现锁可用，就可以自动恢复到RUNNABLE状态了

锁对象.notifyAll()，该方法可以在等待池中，唤醒所有等待指定锁对象的线程，使得这个线程进入到锁池中，而进入到锁池的线程，一旦发现锁可用，就可以自动恢复到RUNNABLE状态了

思考，线程调用无参的wait方法，会释放锁并进入等待池，且此时的状态为WAITING，如果线程调用有参的wait方法，指定一个等待时间，那么线程释放锁后，进入到等待池，此时的状态还是WAITING么？

那就不是的，如果指定了一个等待时间，那状态就是timed_waiting了，这两者的区别就是waiting是一定要通过别的方法唤醒它才能进入就绪状态，而timed_waiting只要时间到了自动变为就绪状态同其他线程争取时间片。

案例：

根据以下代码，补全pos和wit方法完成其功能

要求，银行账号的余额不能是负数

public class Account {
    //账号余额
    private int balance;
    public Account(int balnace) {
        this.balance = balnace;
    }
    //存钱
    public void pos(int money){

    }
    //消费
    public void wit(int money){

    }
}

//男孩,负责挣钱
public class Boy extends Thread{
    private Account account;
    public Boy(Account account, String name) {
        this.account = account;
        setName(name);
    }
    public void run() {
        //一直不停的挣钱
        while(true){
            //随机钱数
            int money = (int)(Math.random()*10000+1);
            //存进账户
            account.pos(money);
            try {
                //休息1秒后，继续挣钱
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

//女孩,负责花钱
public class Girl extends Thread{
    private Account account;
    public Girl(Account account, String name) {
        this.account = account;
        setName(name);
    }
    public void run() {
        //一直不停的花钱
        while(true){
            //随机钱数（看心情）
            int money = (int)(Math.random()*10000+1);
            //刷卡消费
            account.wit(money);
            try {
                //休息1秒后，继续花钱
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class AccountTest {
    public static void main(String[] args) {
        Account account = new Account(5000);
        Boy boy = new Boy(account, "tom");
        Girl lily1 = new Girl(account, "lily1");
        Girl lily2 = new Girl(account, "lily2");
        Girl lily3 = new Girl(account, "lily3");

        boy.start();
        lily1.start();
        lily2.start();
        lily3.start();
    }
}

8 死锁

在程序中要尽量避免出现死锁情况，一旦发生那么只能手动停止JVM的运行，然后查找并修改产生死锁的问题代码

简单的描述死锁就是：俩个线程t1和t2，t1拿着t2需要等待的锁不释放，而t2又拿着t1需要等待的锁不释放，俩个线程就这样一直僵持下去。

例如，

public class ThreadDeadLock extends Thread{
    private Object obj1;
    private Object obj2;

    public ThreadDeadLock(Object obj1,Object obj2) {
        this.obj1 = obj1;
        this.obj2 = obj2;
    }

    public void run() {
        String name = Thread.currentThread().getName();
        if("Thread-0".equals(name)){
            while(true){
                synchronized (obj1) {
                    synchronized (obj2) {
                        System.out.println(name+" 运行了..");
                    }
                }
            }
        }
        else{
            while(true){
                synchronized (obj2) {
                    synchronized (obj1) {
                        System.out.println(name+" 运行了..");
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        Object obj1 = new Object();
        Object obj2 = new Object();
        Thread t1 = new ThreadDeadLock(obj1,obj2);
        Thread t2 = new ThreadDeadLock(obj1,obj2);
        t1.start();
        t2.start();
    }
}