chapter18 【线程、同步】-笔记

【线程、同步】

主要内容

线程

同步

线程状态

教学目标

能够描述Java中多线程运行原理

能够使用继承类的方式创建多线程

能够使用实现接口的方式创建多线程

能够说出实现接口方式的好处

能够解释安全问题的出现的原因

能够使用同步代码块解决线程安全问题

能够使用同步方法解决线程安全问题

能够说出线程6个状态的名称

第一章线程

1.1 多线程原理

先画个多线程执行时序图来体现一下多线程程序的执行流程。

代码如下：

自定义线程类：

public class MyThread extends Thread{
    /*
    * 利用继承中的特点 
    * 将线程名称传递 进行设置 
    */ 
    public MyThread(String name){ 
        super(name); 
    }
    /*
    * 重写run方法 
    * 定义线程要执行的代码 
    */ 
    public void run(){ 
        for (int i = 0; i < 20; i++) {
            //getName()方法 来自父亲
            System.out.println(getName()+i);
        } 
    } 
}

测试类：

public class Demo {
    public static void main(String[] args) {
        System.out.println("这里是main线程");
        MyThread mt = new MyThread("小强");
        mt.start();//开启了一个新的线程 
        for (int i = 0; i < 20; i++) {
            System.out.println("旺财:"+i);
        } 
    } 
}

流程图：

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的

start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。

通过这张图我们可以很清晰的看到多线程的执行流程，那么为什么可以完成并发执行呢？我们再来讲一讲原理。

多线程执行时，到底在内存中是如何运行的呢？以上个程序为例，进行图解说明：

多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。

当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

1.2 Thread类

在上一天内容中我们已经可以完成最基本的线程开启，那么在我们完成操作过程中用到了 java.lang.Thread 类，

API中该类中定义了有关线程的一些方法，具体如下：

构造方法

public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字

常用方法

public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

知创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式

创建线程的方式

1.第一种继承Thread类方式

示例代码

获取线程的名称

Thread类

public class MyThread extends Thread{
    @Override
    public void run(){
        // public String getName() :获取当前线程名称
        String name = getName();
        System.out.println(name);
        
        // Thread-0
        
        // public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
        // 是一个静态方法，返回的是一个线程
        Thread t= Thread.currentThread();
        System.out.println(t);
        // Thread[Thread-0,5,main]
        
        System.out.println(t.getName());
        // Thread-0
        
        // 链式编程
        System.out.println(Thread.currentThread().getName());
    }
}

测试类

public static void(String[] args){
    //创建Thread类中的子类对象
        MyThread mt = new MyThread();
        // 调用start方法，开启心的线程，执行run方法
        mt.start();

        new MyThread().start();
    }

设置线程的名称

Thread类

/*
设置线程的名称：
	1.使用thread类中的getName方法
		void setName(String name) 改变线程名称，使参数name相同
	2.创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参数的构造方法，把线程名称传递给父类，让父类（Thread）给子线程起一个名字
		Thread(String name)分配新的 Thread 对象
*/
public class MyThread extends Thread{
    @Oerride
    public void run(){
        System.out.println(Thread.currentThread().getName());
    }
    public MyThread(){}
    public MyThread(String name){
        // 把线程名称传递给父类，让父类（Thread）给子线程起一个名字
        super(name);
    }
}

测试类

public static void main(String[] args){
    // 开启多线程
    MyThread mt = new MyThread();
    mt.setName("二郎神");
    mt.start();
    
    // 开启多线程
    new MyThrad("哮天犬").start();
}

程序暂停指定的时间

/*
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。 
*/
public static void main(String[] args){
    for(int i = 1;i<=60;i++){
        System.out.println(i);
    }
    // 使用thread类中的sleep方法让程序睡眠一分钟
    try{
		Thread.sleep(1000);
    }catch(InterruptedException e){
        e.printStackTreace();
    }
}

1.3 创建线程方式二

2.第二种实现Runnable接口方式

java.lang.Runnable

Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参方法

java.lang.Thread类的构造方法

Thread(Runnable target) 分配新的Treach对象

Thread(Runnable target，String name) 分配新的Treach对象

实现步骤：

创建一个Runnable接口的实现类
在实现类中重写Runnable接口中的run方法，设置线程任务
创建一个Runnable接口的实现类对象
创建Thread类对象，构造方法中传递Runnable接口的实现类对象
调用Thread类中的start方法，开启新的线程

示例代码

// 创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
   //  在实现类中重写Runnable接口中的run方法，设置线程任务
    @Override
    public void run(){
        for(int i = 0;i<6;i++){
            System.out.prinln(Thread.currentThrad().getName()+"---"+i);
        }
    }
}

测试类

public class Demo01Runnable {
    public static void main(String[] args) {
        // 创建一个Runnable接口的实现类对象
    	Runnable run = new RunnableImpl();
        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t = new Tread(run);
        // 调用Thread类中的start方法，开启新的线程
        t.start();

        for (int i = 0; i < 6; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
    // 运行结果
    main---0
main---1
main---2
main---3
main---4
main---5
Thread-0---0
Thread-0---1
Thread-0---2
Thread-0---3
Thread-0---4
Thread-0---5

1.4 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

总结：

实现Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用 java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程

1.5 匿名内部类方式实现线程的创建

匿名：没有名字

内部类：写在其他类内部的类

匿名内部类的作用：简化代码

把子类继承父类，重写父类的方法，创建子类对象合为一步完成

把实现类实现类接口，重写接口中的方法，创建实现类对象合为一步完成

匿名内部类最终产物：子类/实现类对象，而这个类没有名字

public static void main(String[] args) {
        // 线程的父类是Thread
        // new MyThread().start();
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 8; i++) {
                    System.out.println(Thread.currentThread().getName()+"--"+"coll");
                }
            }
        }.start();

        // 线程接口Runnable
        // Runnable r = new Runnable();多态
        Runnable r = new Runnable(){
            // 重写run方法，设置线程任务

            @Override
            public void run() {
                for (int i = 0; i < 8; i++) {
                    System.out.println(Thread.currentThread().getName()+"--"+"luncry");
                }
            }
        };
        new Thread(r).start();

        // 简化接口的方式
        new Thread(new Runnable(){
            // 重写run方法，设置线程任务

            @Override
            public void run() {
                for (int i = 0; i < 8; i++) {
                    System.out.println(Thread.currentThread().getName()+"--"+"完事");
                }
            }
        }).start();
    }
}

第二章线程安全

2.1 线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样

的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

我们通过一个案例，演示线程的安全问题：

电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个

(本场电影只能卖100张票)。

我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)

需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟

模拟票

public class RunnableImpl implements Runnable{
    // 定义一个多线程共享的票源
    private int ticket = 6;
    // 设置线程任务，卖票
    @Override
    public void run(){
        // 使用死循环让卖票重复执行
        while(true){
            if(ticket>0){// 有票可卖
                // 提高线程安全问题出现的概率，让程序睡眠
                try{
                    Thread.sleep(100);
                }catch(InterruptedException e){
                     e.printStackTrace();
                }
                // 票存在，卖票 ticket--
                String name = Thread.currentThread().getName();
                System.out.println(name+"正在卖第"+ticket--)
            }
        }
    }
}

实现类

public static void main(String[] args){
    // 创建Runnable接口的实现类对象
 	RunnableImpl run = new RunnableImpl();
    // 创建thread类对象，构造方法中传递Runnable接口的实现类对象
    // public Thread() :分配一个新线程对象
    Thread t1 = new Thread(run,"窗口1" );
    Thread t2 = new Thread(run,"窗口2" );
    Thread t3 = new Thread(run,"窗口3" );
    
    // 调用Static方法开启多线程
    t1.start();
    t2.start();
    t3.start();
}
// 运行结果
窗口2正在卖第6
窗口3正在卖第6
窗口1正在卖第5
窗口1正在卖第4
窗口3正在卖第3
窗口2正在卖第4
窗口1正在卖第2
窗口2正在卖第0
窗口3正在卖第1
窗口2正在卖第-1

发现程序出现了两个问题：

相同的票数,比如6这张票被卖了两回。
不存在的票，比如0票与-1票，是不存在的。

这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

2.2 线程同步

当我们使用多个线程访问统一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制

(synchronized)来解决。

根据案例简述

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU 资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象

同步操作

有三种方式完成同步操作：

同步代码块。
同步方法。
锁机制。

2.3 解决线程安全方法一同步代码块

同步代码块：synchronized 关键字可以用于方法中的某个代码块中，表示只对这块的资源实行互斥访问

格式

synchronize(同步锁){
    需要同步操作的代码
}

注意

通过代码块中的锁对象，可以使用任意的对象
但是必须保证多个线程使用的锁对象是同一个
锁对象作用：

把同步代码块锁住，只让一个线程在同步代码块中执行

使用同步代码块解决卖票案例出现的线程安全问题，卖出了不存在的票和重复票的问题

Ticket类

public class RunnableImpl implements Runnable{
   // 创建一个共享数据的票源
    private int ticket = 10;
    // 创建一个锁对象
    Object obj = new object();
    
    // 设置线程任务，卖票
    @Override
    public void run(){
        // 使用死循环让带吗重复操作
        while(true){
            // 同步代码块
            synchronized(obj){
                // 先判断票是否存在
            if(tick>0){
                // 提高安全问题出现的概率，让程序睡眠
                try{
                    Thread.sleep(100);
                }catch(InterrutedException e){
                    e.printStackTrace();
                }
                
                // 票存在  卖票 ticket--
            	System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }
            
        }
    }
}

测试类

public static void main(String[] args){
    RunnableImpl run = new RunnableImpl();
    // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
    Thread t1 = new Thread(run);
    Thread t2 = new Thread(run);
    Thread t3 = new Thread(run);
    // 调用start方法开启多线程
        t3.start();
        t1.start();
        t2.start();
}
// 运行结果一部分
Thread-2正在卖第64张票
Thread-1正在卖第63张票
Thread-1正在卖第62张票
Thread-1正在卖第61张票
Thread-0正在卖第60张票
Thread-1正在卖第59张票
Thread-2正在卖第58张票
Thread-2正在卖第57张票

原理

2.4 解决线程安全方法二同步方法

同步方法：使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

格式

修饰符  synchronize 返回值类型 方法名称（参数列表）{
    可能会出现线程安全问题的代码（访问了共享数据的代码）
}

同步锁是谁?

对于非static方法,同步锁就是this。

对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

注意

通过代码块中的锁对象，可以是任意的对象
但必须保证多个线程使用的锁对象是同一个
锁对象作用：

把同步代码块锁住，只让一个线程在同步代码块中执行

原理

定义一个同步方法

同步方法会把方法的内部的代码锁住

只让一个线程执行

同步方法的锁对象就是实现对象 new RunnableImpl()

也就是this

使用同步方法代码如下

public class RunnableImpl implements Runnable{
    privat int ticked = 100;
    // 执行卖票操作
    @Override
    public void run(){
        while(true){
            
        }
    }
    // 锁对象 是 谁调用这个方法 就是谁
    // 隐含 锁对象 就是 this
    public synchronized void sellTicked(){
        if(ticked>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‐‐);
        }
    }
}

2.5 解决线程安全方法三 Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和*synchronized**方法更广泛的锁定操作,

同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock() :加同步锁。
public void unlock() :释放同步锁。

public class Ticket implements Runnable{ 
    private int ticket = 100;
    Lock lock = new ReentrantLock();
    /** 执行卖票操作 */
    @Override public void run() {
        //每个窗口卖票的操作 
        //窗口 永远开启 
        while(true){ 
            lock.lock(); 
            if(ticket>0){//有票 可以卖
                //出票操作 
                //使用sleep模拟一下出票时间
                try {Thread.sleep(50); 
                    } catch (InterruptedException e) {
                    // TODO Auto‐generated catch block 
                    e.printStackTrace();
                }
                //获取当前线程对象的名字
                String name = Thread.currentThread().getName(); 
                System.out.println(name+"正在卖:"+ticket‐‐); 
            }lock.unlock();
        } 
    }
}

第三章线程状态

3.1 线程状态概述

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态

线程状态	导致状态发生条件
New（新建）	线程刚被创建，但是并未启动，还没调用start方法
Runnable（可运行）	线程可以在java虚拟机中运行状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器
Blocked（锁阻塞）	当线程试图获取一个对象锁，而该对象锁被其他线程所持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态
Waitihng（无限等待）	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态，进入这个状态后不能自动唤醒，必须等待另一个线程调用notify或者notifyAll方法才能唤醒
Timed Waiting（计时等待）	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态，这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep、Object.wait.
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡

![](E:\云盘\个人总结\01_Java基础语法\day06_线程、同步总结\img\线程的状态图.png)

3.2 Timed Waiting（计时等待）

其实当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting(计时等

待)

实现一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串

示例代码

public class MyThread extends Thread{
    @Override
    public void run(){
        for(int i = 1;i<100;i++){
            if(i % 10 ==0){
                System.out.println("--"+i+"秒");
            }
            System.out.println(i);
            tty{
                Thread.sleep(1000);
            }catch (InterruptedException e) { 
                e.printStackTrace(); 
            }
        }
    }
    public static void main(String[] args){
        new MyThread().start();
    }
    
}

通过案例可以发现，sleep方法的使用还是很简单的。我们需要记住下面几点：

进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协

作关系。

为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程

中会睡眠

sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。

小提示：sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就

开始立刻执行。

Timed Waiting 线程状态图：

3.3 BLOCKED（锁阻塞）

Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

我们已经学完同步机制，那么这个状态是非常好理解的了。比如，线程A与线程B代码中使用同一锁，如果线程A获

取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。

这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态

Blocked 线程状态图

3.4 Witing（无限等待）

Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

等待唤醒案例：线程之间的通信

创建一个顾客：告知老板需要的物品，调用wait方法，放弃CPU的执行，进入到WAITING状态（无限等待）
创建一个老板：花了5秒准备好物品，调用notify方法，唤醒顾客取走

注意：

顾客与老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
同步使用的锁对象必须保证唯一
只有锁对象才能调用wait和notify方法

Object类中的方法

void wait()

在其他线程调用此对象的notify（）方法或notifyAll（）方法前，导致当前线程等待

void notify()

唤醒再此对象监视器上等待的单个线程

会唤醒执行wait方法之后的代码

示例代码：

public static void main(String[] args){
    // 创建对象  保证唯一
    Object obj = new Object();
    // 创建顾客线程
    new Thread(){
    	@Override
    		public void run(){
                // 保证等待和唤醒的线程只能有一个执行，需要使用用同步技术
        synchronized(obj){
        Sysetem.out.println("告诉老板需要的物品");
        // 调用wait方法，放弃CPU的执行，进入到WAITING状态（无限等待）
        try{
            obj.wait();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        // 唤醒之后执行的代码
        System.out.println("拿上东西，付款走人");
        }
    }
}.start();

// 创建一个老板生产者
new Thrad(){
    @Override
    public void run(){
        // 花了5秒准备物品
        try{
            Thread.Sleep("5000");
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        // 保证等待和唤醒的线程只能有一个执行，需要使用用同步技术
        synchronized(obj){
            System.out.println("物品准备好了，提醒顾客");
            // 调用notify方法，唤醒顾客
            obj.notify();
        }
    }
}.start();

第四章唤醒

进入到TimeWating（计时等待）有两种方式

使用sleep（long m）方法，在毫秒值结束后，线程睡醒进入到Runnable/ Blocked状态
使用wait（long m）方法，wait方法如果在毫秒值结束后，没有被notify唤醒，就会自动醒来进入到Runnable/ Blocked状态

唤醒方法

void notify();唤醒此监视器上等待的单个线程

void notifyAll() 唤醒此监视器上等待的所有线程

，一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的

Object.notify()方法或 Object.notifyAll()方法。

其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，

多个线程会争取锁，同时相互之间又存在协作关系。就好比在公司里你和你的同事们，你们可能存在晋升时的竞

争，但更多时候你们更多是一起合作以完成某些任务。

当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入

了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了

notify()方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入

Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）。

Waiting 线程状态图

补充知识点

一条有意思的tips:

我们在翻阅API的时候会发现Timed Waiting（计时等待）与 Waiting（无限等待）状态联系还是很紧密的，比如Waiting（无限等待）状态中wait方法是空参的，而timed waiting（计时等待）中wait方法是带参的。

这种带参的方法，其实是一种倒计时操作，相当于我们生活中的小闹钟，我们设定好时间，到时通知，可是

如果提前得到（唤醒）通知，那么设定好时间在通知也就显得多此一举了，那么这种设计方案其实是一举两得。如果没有得到（唤醒）通知，那么线程就处于Timed Waiting状态,直到倒计时完毕自动醒来；如果在倒计时期间得到（唤醒）通知，那么线程从Timed Waiting状态立刻唤醒。

posted @ 2020-03-31 21:12 _Anke 阅读(118) 评论(0) 编辑收藏举报

刷新页面返回顶部

_Anke

chapter18 【线程、同步】-笔记

chapter18 【线程、同步】-笔记

第一章 线程

1.1 多线程原理

1.2 Thread类

构造方法

常用方法

创建线程的方式

1.第一种继承Thread类方式

获取线程的名称

设置线程的名称

程序暂停指定的时间

1.3 创建线程方式二

2.第二种实现Runnable接口方式

1.4 Thread和Runnable的区别

1.5 匿名内部类方式实现线程的创建

第二章 线程安全

2.1 线程安全

2.2 线程同步

同步操作

2.3 解决线程安全方法一 同步代码块

格式

注意

原理

2.4 解决线程安全方法二 同步方法

格式

注意

原理

2.5 解决线程安全方法三 Lock锁

第三章 线程状态

3.1 线程状态概述

3.2 Timed Waiting（计时等待）

3.3 BLOCKED（锁阻塞）

3.4 Witing（无限等待）

第四章 唤醒

唤醒方法

补充知识点

公告

第一章线程

第二章线程安全

2.3 解决线程安全方法一同步代码块

2.4 解决线程安全方法二同步方法

第三章线程状态

第四章唤醒