Java线程的创建、运行、生命周期以及常用方法

yqd666

已于 2024-03-12 13:11:18 修改

阅读量273

点赞数

文章标签： java jvm 面试

于 2022-08-26 11:22:26 首次发布

本文链接：https://blog.csdn.net/y516369/article/details/126497223

版权

1.线程的创建方式

在这里插入图片描述

1.1 继承Thread类，重写run方法

// 创建线程对象,构造方法的参数是给线程指定名字，推荐
Thread t1 = new Thread("t1") {
	@Override
	// run 方法内实现了要执行的任务
	public void run() {
		log.debug("hello");
} };
t1.start();

1.2 使用 Runnable 配合 Thread

（1）把【线程】和【任务】（要执行的代码）分开
①Thread 代表线程
②Runnable 可运行的任务（线程要执行的代码）

// 创建任务对象
Runnable task2 = new Runnable() {
	@Override
	public void run() {
		log.debug("hello");
} };
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();

（2）Thread 与 Runnable 的关系
①继承Thread类是把线程和任务合并在了一起，使用 Runnable 配合 Thread是把线程和任务分开了
②用 Runnable 更容易与线程池等高级 API 配合
③用 Runnable 让任务类脱离了 Thread 继承体系，更灵活
④Java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时再用继承Thread类方法来实现创建线程显然不可能了。
⑤Java设计者提供了另外一种创建线程的方法，就是通过实现Runnable接口来创建线程。实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable

（3）Java 8 以后可以使用 lambda 精简代码

// 创建任务对象
Runnable task2 = () -> log.debug("hello");
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();

1.3 FutureTask 配合 Thread

（1）FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况
在这里插入图片描述
（2）Callable与Runnable区别是有返回值，可以抛异常
（3）例子：

public class DemoFutureTask {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
       FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {
           @Override
           public Integer call() throws Exception {
               return 100;
           }
       });
        Thread t1 = new Thread(task,"t1");
        t1.start();
        System.out.println(task.get()); //100

    }
}

2.线程运行原理

2.1 栈与栈帧

（1）Java Virtual Machine Stacks （Java 虚拟机栈）
我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟机就会为其分配一块栈内存。
①每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
②每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

2.2 线程上下文切换（Thread Context Switch）

（1）CPU通过分配时间片来执行任务，当一个任务的时间片用完，就会切换到另一个任务。在切换之前会保存上一个任务的状态，当下次再切换到该任务，就会加载这个状态。任务从保存到再加载的过程就是一次上下文切换
（2）因为以下一些原因会导致 cpu 不再执行当前的线程，转而执行另一个线程的代码
①线程的 cpu 时间片用完
②垃圾回收
③有更高优先级的线程需要运行
④线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法
（2）当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的
①状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
②Context Switch 频繁发生会影响性能

3.通知线程退出

（1）当线程退出后,会自动退出
（2）还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

public class Thread_exit {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();
//        如果希望main线程去控制t1 线程的终止，可以修改 loop
//        让t1 退出run方法，从而终止 t1线程 -> 通知方式
//        让主线程休眠 10秒，再通知 t1线程退出
        Thread.sleep(10 * 1000);
        t.setLoop(false);
    } }
class T extends Thread {
    private int count = 0;
    //    设置一个控制变量
    private boolean loop = true;
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
    @Override
    public void run() {
        while (loop) {
            System.out.println("我是" + (++count) + "线程名=" + Thread.currentThread().getName());
//        让线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            } } } }

3.线程常用方法

3.1 setName和getName

（1）setName：设置线程名称，使之与参数name相同
（2）getName：返回该线程的名称

3.2 start

（1）使该线程开始执行；Java虚拟机底层调用该线程的start0 方法
（2） start()方法源码：
① public synchronized void start() {
start0();
}
② start0() 是本地方法，是JVM调用，底层是c/c++实现
真正实现多线程效果的是start0()，而不是 run
private native void start0();
*/
（3）
在这里插入图片描述

3.3 run

调用线程对象的run方法，新线程启动后会调用的方法。如果在构造 Thread 对象时传递了 Runnable 参数，则线程启动后会调用 Runnable 中的 run 方法，否则默认不执行任何操作。但可以创建 Thread 的子类对象，来覆盖默认行为

3.4 setPriority和getPriority

（1）setPriority：更改线程的优先级
①线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
②如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用
在这里插入图片描述
（2）getPriority：获取线程的优先级

3.5 sleep和yield

（1）sleep：在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
①调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
②其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
在这里插入图片描述
③睡眠结束后的线程未必会立刻得到执行(睡眠结束以后CPU可能正在执行其他的线程)
④建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性(有时间的单位)
例如：TimeUnit.SECONDS.sleep(1000);
（2）yield
①线程的礼让。让出CPU，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功。具体的实现
依赖于操作系统的任务调度器
②调用 yield 会让当前线程从 Running进入Runnable 就绪状态，然后调度执行其它线程

3.6 interrupt，isInterrupted

3.6.1 interrupt

（1）打断sleep，wait，join这些处于阻塞的线程，并且会清空打断状态

private static void test1() throws InterruptedException {
Thread t1 = new Thread(()->{
	sleep(1);
	}, "t1");
	t1.start();
	sleep(0.5);
	t1.interrupt();
	log.debug(" 打断状态: {}", t1.isInterrupted());//false
}

（2）打断正常运行的线程
被打断的线程只是知道有其他线程想要打断自己,但是被打断的线程是由自己决定继续运行还是停止运行。
打断正常运行的线程, 不会清空打断状态。我们可以根据打断状态来判断是继续运行还是停止运行。

public class DemoInterrupt {
    public static void main(String[] args) throws InterruptedException {
//只是知道有其他线程想要打断我,但是被打断的线程是由自己决定继续运行还是停止运行
        Thread t1 = new Thread(() -> {
            while (true) {
                boolean interrupted = Thread.currentThread().isInterrupted();
                if (interrupted) {
                    System.out.println("有人要打断你");
                    break;
                } } });
        t1.start();
        Thread.sleep(1000);
        t1.interrupt();
    } }

3.6.2 isInterrupted

isInterrupted() 判断是否被打断，不会清除打断标记

3.6.3 interrupted()

static方法，判断当前线程是否被打断，会清除打断标记

3.7 join

（1）join()：等待线程运行结束
（2）join(long n)：等待线程运行结束,最多等待n毫秒

3.8 getState和currentThread

（1）getState:获取线程的状态
（2）currentThread()方法：Thread.currentThread()方法可以获得当前线程。
Java中的任何一段代码都是执行在某个线程当中的. 执行当前代码的线程就是当前线程。同一段代码可能被不同的线程执行,因此当前线程是相对的,Thread.currentThread()方法的返回值是在代码实际运行时候的线程对象。

3.9 不推荐的方法

还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁
方法名 static 功能说明
（1）stop() 停止线程运行
（2）suspend() 挂起（暂停）线程运行
（3）resume() 恢复线程运行

4.用户线程和守护线程

（1）用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
（2）守护线程：一般是为工作线程服务的，当所有用户线程结束，守护线程自动结束
常见的守护线程：垃圾回收机制
（3）把线程设置为守护线程例子

public class ThreadMethod3 {
    public static void main(String[] args) throws InterruptedException {
        T3 t3 = new T3();
//        如果我们希望当main线程结束后，子线程自动结束
//        只需将子线程设为守护线程即可
        t3.setDaemon(true);
        t3.start();
        for (int i = 0; i < 10; i++) {//主线程
            System.out.println("别卷了..."+i);
            Thread.sleep(1000);
        } } }
class T3 extends Thread{
    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(1000);//休息1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("在学Java...");
        } } }

5.线程的生命周期

5.1 从操作系统层面来描述

在这里插入图片描述
（1）【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联
（2）【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
（3）【运行状态】指获取了 CPU 时间片运行中的状态。当CPU时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
（4）【阻塞状态】
①如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】
②等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
③与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑
调度它们
（5）【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

5.2 从 Java API 层面来描述

在这里插入图片描述

线程的生命周期是线程对象的生老病死,即线程的状态。线程生命周期可以通过getState()方法获得, 线程的状态是Thread.State枚举类型定义的, 由以下几种：

NEW：新建状态. 创建了线程对象,在调用start()启动之前的状态。
RUNNABLE：可运行状态. 它是一个复合状态,包含:READY和RUNNING两个状态. READY状态该线程可以被线程调度器进行调度使它处于RUNNING状态, RUNING状态表示该线程正在执行. Thread.yield()方法可以把线程由RUNNING状态转换为READY状态。
BLOCKED：阻塞状态.线程发起阻塞的I/O操作,或者申请由其他线程占用的独占资源,线程会转换为BLOCKED阻塞状态. 处于阻塞状态的线程不会占用CPU资源. 当阻塞I/O操作执行完,或者线程获得了其申请的资源,线程可以转换为RUNNABLE。
WAITING：无限期地等待另一个线程来执行某一特定操作。线程执行了object.wait(), thread.join()方法会把线程转换为WAITING等待状态, 执行object.notify()方法,或者加入的线程执行完毕,当前线程会转换为RUNNABLE状态。
TIMED_WAITING：等待另一个线程来执行操作，取决于指定的等待时间
TERMINATED：终止状态,线程结束处于终止状态

（1）情况 1 NEW --> RUNNABLE
当调用 t.start() 方法时，由 NEW --> RUNNABLE
（2）情况 2 RUNNABLE <–> WAITING
t 线程用 synchronized(obj) 获取了对象锁后
①调用 obj.wait() 方法时，t 线程从 RUNNABLE --> WAITING
②调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
竞争锁成功，t 线程从 WAITING --> RUNNABLE
竞争锁失败，t 线程从 WAITING --> BLOCKED
（3）情况 3 RUNNABLE <–> WAITING
①当前线程调用 t.join() 方法时，当前线程从 RUNNABLE --> WAITING
注意是当前线程在t 线程对象的监视器上等待
②t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 WAITING --> RUNNABLE
（4）情况 4 RUNNABLE <–> WAITING
①当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE --> WAITING
②调用 LockSupport.unpark(目标线程) 或调用了线程的 interrupt() ，会让目标线程从 WAITING -->
RUNNABLE
（5）情况 5 RUNNABLE <–> TIMED_WAITING
t 线程用 synchronized(obj) 获取了对象锁后
①调用 obj.wait(long n) 方法时，t 线程从 RUNNABLE --> TIMED_WAITING
②t 线程等待时间超过了 n 毫秒，或调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
竞争锁成功，t 线程从 TIMED_WAITING --> RUNNABLE
竞争锁失败，t 线程从 TIMED_WAITING --> BLOCKED
（6）情况 6 RUNNABLE <–> TIMED_WAITING
当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE --> TIMED_WAITING
注意是当前线程在t 线程对象的监视器上等待
当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从
TIMED_WAITING --> RUNNABLE
（7）情况 7 RUNNABLE <–> TIMED_WAITING
当前线程调用 Thread.sleep(long n) ，当前线程从 RUNNABLE --> TIMED_WAITING
当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING --> RUNNABLE
（8）情况 8 RUNNABLE <–> TIMED_WAITING
当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线
程从 RUNNABLE --> TIMED_WAITING
调用 LockSupport.unpark(目标线程) 或调用了线程的 interrupt() ，或是等待超时，会让目标线程从
TIMED_WAITING–> RUNNABLE
（9）情况 9 RUNNABLE <–> BLOCKED
t 线程用 synchronized(obj) 获取了对象锁时如果竞争失败，从 RUNNABLE --> BLOCKED
持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED 的线程重新竞争，如果其中 t 线程竞争
成功，从 BLOCKED --> RUNNABLE ，其它失败的线程仍然 BLOCKED
（10）情况 10 RUNNABLE <–> TERMINATED
当前线程所有代码运行完毕，进入 TERMINATED

6.线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
我们通过一个案例，演示线程的安全问题：
电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。
我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)
需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟
模拟票：

public class Ticket implements Runnable {
private int ticket = 100;
/*
* 执行卖票操作
*/
@Override
public void run() {
//每个窗口卖票的操作
//窗口 永远开启
while (true) {
if (ticket > 0) {//有票 可以卖
//出票操作
//使用sleep模拟一下出票时间
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto‐generated catch block
e.printStackTrace();
} /
/获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name + "正在卖:" + ticket‐‐);
}}}}
//测试类：
public class Demo {
public static void main(String[] args) {
//创建线程任务对象
Ticket ticket = new Ticket();
//创建三个窗口对象
Thread t1 = new Thread(ticket, "窗口1");
Thread t2 = new Thread(ticket, "窗口2");
Thread t3 = new Thread(ticket, "窗口3");
//同时卖票
t1.start();
t2.start();
t3.start();
} }

在这里插入图片描述

7.线程同步机制

（1）在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。
（2）也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

7.1 同步具体方法-Synchronized

（1）同步代码块
synchronized(对象) { //得到对象的锁，才能操作同步代码
// 需要被同步的代码；
}
（2）synchronized还可以放在方法声明中，表示整个方法为同步方法
public synchronized void m(String name) {
// 需要被同步的代码
}

7.2 Lock锁

（1）从JDK5.0 开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步；同步锁使用Lock对象充当
（2）java.util.concurrent.locks.Lock接口是控制多个线程对资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
（3）ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁

// 获取锁
reentrantLock.lock();
try {
	// 临界区
} finally {
	// 释放锁
	reentrantLock.unlock();
}

public class TestLock {
    public static void main(String[] args) {
        DemoLock demoLock = new DemoLock();
        new Thread(demoLock).start();
        new Thread(demoLock).start();
        new Thread(demoLock).start();
 } }
class DemoLock implements Runnable {
    int tickNums = 10;
    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            lock.lock();//加锁(位置放在try块里面和外面效果都一样)
            try {
                if (tickNums > 0) {
                    System.out.println(tickNums--);
                } else {
                    break;
                }
            } finally {
                lock.unlock();//解锁
            }  } } }

7.3 Lock与synchronized对比

（1）Lock是显示锁(手动开启和关闭锁)，synchronized是隐式锁，出了作用域自动释放
（2）Lock只有代码块锁，synchronized有代码块锁和方法锁
（3）使用Lock锁，JVM将花费较短时间来调度线程，性能更好。并且具有更好的扩展性(提供了更多的子类)
（4）ReentrantLock可中断,可以设置超时时间,可以设置为公平锁,支持多个条件变量;与 synchronized 一样，
都支持可重入
①可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁;
如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住

static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
	method1();
}
public static void method1() {
	lock.lock();
	try {
		log.debug("execute method1");
		method2();
} finally {
	lock.unlock();
   } }
//第二次调用和第三次调用就相当于重入
public static void method2() {
	lock.lock();
	try {
		log.debug("execute method2");
		method3();
	} finally {
		lock.unlock();
} }

②可打断，等待锁的过程中，其他线程可以使用interrupt方法终止我的等待
(获取锁方式为lock.lockInterruptibly())

public class Test1 {
    private static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
//  如果没有竞争那么此方法就会获取lock对象锁
//  如果有竞争就会进入阻塞队列，可以被其他线程使用 interrupt方法打断
                System.out.println("尝试获取锁");
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("没有获得锁,返回");
                return;
            }
            try {
                System.out.println("获取到锁");
            } finally {
                lock.unlock();
            }});
        lock.lock();//主线程获取锁
        t1.start();//t1线程
        t1.interrupt();//打断t1
    } }

③锁超时(获取锁的方式为lock.tryLock())
还可以设置超时时间-lock.tryLock(1, TimeUnit.SECONDS)

ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
	log.debug("启动...");
	if (!lock.tryLock()) {
		log.debug("获取锁失败，返回");
		return;
}
	try {
		log.debug("获得了锁");
	} finally {
		lock.unlock();
} }, "t1");
	lock.lock();//主线程获取锁
	log.debug("获得了锁");
	t1.start();
	try {
		sleep(2);
	} finally {
		lock.unlock();
	}

④ReentrantLock 默认是不公平的(公平锁一般没有必要，会降低并发度)
ReentrantLock lock = new ReentrantLock(false);//改为公平锁
不公平锁：当一个线程池有锁，其他线程就会进入阻塞队列去等待，当锁的持有者释放锁时，这些线程就会一涌而上，谁先抢到谁就先获得锁，而不会按照进入阻塞队列的顺序
l

8.互斥锁(就是上面的对象锁)

（1）在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性
（2）每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问
（3）关键字synchronized 用来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
（4）同步的局限性：导致程序的执行效率要降低
（5）同步方法(非静态的)的锁可以是this，也可以是其他对象(要求是同一个对象)
（6）同步方法(静态的)的锁为当前类本身
注意事项：
①同步方法如果没有使用static修饰，默认锁对象为this
②如果方法使用static修饰，默认锁对象：当前类.class
例子：

//1.同步方法没有使用static修饰
public class SellTicket02 {
    public static void main(String[] args) {
        T2 t2 = new T2();
        new Thread(t2).start();//第一个线程窗口
        new Thread(t2).start();//第二个线程窗口
        new Thread(t2).start();//第三个线程窗口
    } }
class T2 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    private boolean loop = true;
    Object object = new Object();
    public void sell() {
        synchronized (/*this*/object) {
            if (ticketNum <= 0) {
                System.out.println("售票结束。。。");
                loop = false;
                return;
            }
//            休眠50秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
                    + "剩余票数=" + (--ticketNum));
        } }
    @Override
    public void run() {
        while (loop) {
            sell();
        } } }

// 2.同步方法为静态方法
public class SellTicket05 {
    public static void main(String[] args) {
        T2 t2 = new T2();
        new Thread(t2).start();//第一个线程窗口
        new Thread(t2).start();//第二个线程窗口
        new Thread(t2).start();//第三个线程窗口
    } }
class T5 implements Runnable {
    private static int ticketNum = 100;//让多个线程共享 ticketNum
    private static boolean loop = true;
    public static void sell() {
        synchronized (T5.class) {
            if ( ticketNum<= 0) {
                System.out.println("售票结束。。。");
                loop = false;
                return;
            }
//            休眠50秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
                    + "剩余票数=" + (--ticketNum));
        } }
    @Override
    public void run() {
        while (loop) {
            sell();
        } } }

9.线程死锁

多个线程都占用了对方的锁资源，但不肯想让，导致了死锁，在编程时一定要避免死锁的发生

public class DeadLock {
    public static void main(String[] args) {
        DemoDeadLock A = new DemoDeadLock(true);
        DemoDeadLock B = new DemoDeadLock(false);
        A.start();
        B.start();
    } }
class DemoDeadLock extends Thread {
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;
    public DemoDeadLock(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
//业务逻辑分析:
// 1.如果flag 为T,线程A 就会先得到 o1 对象锁，然后尝试去获取 o2 对象锁
// 2.如果线程A 得不到 o2 对象锁，就会Blocked
// 3.如果flag 为F,线程B 就会先得到 o2 对象锁，然后尝试去获取 o1 对象锁
// 4.如果线程B 得不到 o1 对象锁，就会Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁，下面就是同步代码
                System.out.println(Thread.currentThread().getName() + "进入1");
                synchronized (o2) {
                    System.out.println(Thread.currentThread().getName() + "进入2");
                } }
        } else {
            synchronized (o2) {//对象互斥锁，下面就是同步代码
                System.out.println(Thread.currentThread().getName() + "进入2");
                synchronized (o1) {
                    System.out.println(Thread.currentThread().getName() + "进入1");
                } } } } }

10.释放锁

（1）当前线程的同步方法、同步代码块执行结束
（2）当前线程在同步代码块、同步方法中遇到break、return
（3）当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
（4）当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁
下面操作不会释放锁：
①线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
②线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁
提示：应尽量避免使用suspend()和resume()来控制线程，该方法不再推荐使用