Java线程小刀牛试
线程简介
什么是线程
现代操做系统调度的最小单元是线程，也叫轻量级进程（Light Weight Process），在一个进程里能够建立多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，而且可以访问共享的内存变量。html
线程生命周期
java.lang.Thread.State 中定义了 6 种不一样的线程状态，在给定的一个时刻，线程只能处于其中的一个状态。java
如下是各状态的说明，以及状态间的联系：git
- 开始（New） - 尚未调用
start()方法的线程处于此状态。 - 可运行（Runnable） - 已经调用了
start()方法的线程状态。此状态意味着，线程已经准备好了，一旦被线程调度器分配了 CPU 时间片，就能够运行线程。 - 阻塞（Blocked） - 阻塞状态。线程阻塞的线程状态等待监视器锁定。处于阻塞状态的线程正在等待监视器锁定，以便在调用
Object.wait()以后输入同步块/方法或从新输入同步块/方法。 - 等待（Waiting） - 等待状态。一个线程处于等待状态，是因为执行了 3 个方法中的任意方法：
Object.wait()Thread.join()LockSupport.park()
- 定时等待（Timed waiting） - 等待指定时间的状态。一个线程处于定时等待状态，是因为执行了如下方法中的任意方法：
Thread.sleep(sleeptime)Object.wait(timeout)Thread.join(timeout)LockSupport.parkNanos(timeout)LockSupport.parkUntil(timeout)
- 终止(Terminated) - 线程
run()方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。
启动和终止线程
构造线程
构造线程主要有三种方式程序员
- 继承
Thread类 - 实现
Runnable接口 - 实现
Callable接口
继承 Thread 类
经过继承 Thread 类构造线程的步骤：github
- 定义 Thread 类的子类，并重写该类的 run() 方法，该 run() 方法的方法体就表明了线程要完成的任务。所以把 run() 方法称为执行体。
- 建立 Thread 子类的实例，即建立了线程对象。
- 调用线程对象的 start() 方法来启动该线程。
示例：数据库
public class ThreadDemo02 {
public static void main(String[] args) {
Thread02 mt1 = new Thread02("线程A "); // 实例化对象
Thread02 mt2 = new Thread02("线程B "); // 实例化对象
mt1.start(); // 调用线程主体
mt2.start(); // 调用线程主体
}
static class Thread02 extends Thread {
private int ticket = 5;
Thread02(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (this.ticket > 0) {
System.out.println(this.getName() + " 卖票：ticket = " + ticket--);
}
}
}
}
}
实现 Runnable 接口
经过实现 Runnable 接口构造线程的步骤：安全
- 定义 Runnable 接口的实现类，并重写该接口的 run() 方法，该 run() 方法的方法体一样是该线程的线程执行体。
- 建立 Runnable 实现类的实例，并依此实例做为 Thread 的 target 来建立 Thread 对象，该 Thread 对象才是真正的线程对象。
- 调用线程对象的 start() 方法来启动该线程。
示例：网络
public class RunnableDemo {
public static void main(String[] args) {
MyThread t = new MyThread("Runnable 线程"); // 实例化对象
new Thread(t).run(); // 调用线程主体
new Thread(t).run(); // 调用线程主体
new Thread(t).run(); // 调用线程主体
}
static class MyThread implements Runnable {
private int ticket = 5;
private String name;
MyThread(String name) {
this.name = name;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (this.ticket > 0) {
System.out.println(this.name + " 卖票：ticket = " + ticket--);
}
}
}
}
}
实现 Callable 接口
经过实现 Callable 接口构造线程的步骤：并发
- 建立 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将做为线程执行体，而且有返回值。
- 建立 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
- 使用 FutureTask 对象做为 Thread 对象的 target 建立并启动新线程。
- 调用 FutureTask 对象的 get() 方法来得到子线程执行结束后的返回值。
示例：dom
public class CallableAndFutureDemo {
public static void main(String[] args) {
Callable<Integer> callable = () -> new Random().nextInt(100);
FutureTask<Integer> future = new FutureTask<>(callable);
new Thread(future).start();
try {
Thread.sleep(1000);// 可能作一些事情
System.out.println(future.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
三种建立线程方式对比
- 实现 Runnable 接口优于继承 Thread 类，由于实现接口方式更便于扩展类。
- 实现 Runnable 接口的线程没有返回值；而实现 Callable 接口的线程有返回值。
中断线程
当一个线程运行时，另外一个线程能够直接经过 interrupt() 方法中断其运行状态。
public class ThreadInterruptDemo {
public static void main(String[] args) {
MyThread mt = new MyThread(); // 实例化Runnable子类对象
Thread t = new Thread(mt, "线程"); // 实例化Thread对象
t.start(); // 启动线程
try {
Thread.sleep(2000); // 线程休眠2秒
} catch (InterruptedException e) {
System.out.println("三、休眠被终止");
}
t.interrupt(); // 中断线程执行
}
static class MyThread implements Runnable {
@Override
public void run() {
System.out.println("一、进入run()方法");
try {
Thread.sleep(10000); // 线程休眠10秒
System.out.println("二、已经完成了休眠");
} catch (InterruptedException e) {
System.out.println("三、休眠被终止");
return; // 返回调用处
}
System.out.println("四、run()方法正常结束");
}
}
}
终止线程
Thread 中的 stop 方法有缺陷，已废弃。
安全地终止线程有两种方法：
- 中断状态是线程的一个标识位，而中断操做是一种简便的线程间交互方式，而这种交互方式最适合用来取消或中止任务。
- 还能够利用一个 boolean 变量来控制是否须要中止任务并终止该线程。
public class ThreadStopDemo03 {
public static void main(String[] args) throws Exception {
MyTask one = new MyTask();
Thread countThread = new Thread(one, "CountThread");
countThread.start();
// 睡眠1秒，main线程对CountThread进行中断，使CountThread可以感知中断而结束
TimeUnit.SECONDS.sleep(1);
countThread.interrupt();
MyTask two = new MyTask();
countThread = new Thread(two, "CountThread");
countThread.start();
// 睡眠1秒，main线程对Runner two进行取消，使CountThread可以感知on为false而结束
TimeUnit.SECONDS.sleep(1);
two.cancel();
}
private static class MyTask implements Runnable {
private long i;
private volatile boolean on = true;
@Override
public void run() {
while (on && !Thread.currentThread().isInterrupted()) {
i++;
}
System.out.println("Count i = " + i);
}
void cancel() {
on = false;
}
}
}
Thread 中的重要方法
run- 线程的执行实体。start- 线程的启动方法。setName、getName- 能够经过 setName()、 getName() 来设置、获取线程名称。setPriority、getPriority- 在 Java 中，全部线程在运行前都会保持在就绪状态，那么此时，哪一个线程优先级高，哪一个线程就有可能被先执行。能够经过 setPriority、getPriority 来设置、获取线程优先级。setDaemon、isDaemon- 可使用 setDaemon() 方法设置线程为守护线程；可使用 isDaemon() 方法判断线程是否为守护线程。isAlive- 能够经过 isAlive 来判断线程是否启动。interrupt- 当一个线程运行时，另外一个线程能够直接经过 interrupt() 方法中断其运行状态。join- 使用 join() 方法让一个线程强制运行，线程强制运行期间，其余线程没法运行，必须等待此线程完成以后才能够继续执行。Thread.sleep- 使用 Thread.sleep() 方法便可实现休眠。Thread.yield- 可使用 Thread.yield() 方法将一个线程的操做暂时让给其余线程执行。
设置/获取线程名称
在 Thread 类中能够经过 setName()、 getName() 来设置、获取线程名称。
public class ThreadNameDemo {
public static void main(String[] args) {
MyThread mt = new MyThread(); // 实例化Runnable子类对象
new Thread(mt).start(); // 系统自动设置线程名称
new Thread(mt, "线程-A").start(); // 手工设置线程名称
Thread t = new Thread(mt); // 手工设置线程名称
t.setName("线程-B");
t.start();
}
static class MyThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName() + "运行，i = " + i); // 取得当前线程的名字
}
}
}
}
判断线程是否启动
在 Thread 类中能够经过 isAlive() 来判断线程是否启动。
public class ThreadAliveDemo {
public static void main(String[] args) {
MyThread mt = new MyThread(); // 实例化Runnable子类对象
Thread t = new Thread(mt, "线程"); // 实例化Thread对象
System.out.println("线程开始执行以前 --> " + t.isAlive()); // 判断是否启动
t.start(); // 启动线程
System.out.println("线程开始执行以后 --> " + t.isAlive()); // 判断是否启动
for (int i = 0; i < 3; i++) {
System.out.println(" main运行 --> " + i);
}
// 如下的输出结果不肯定
System.out.println("代码执行以后 --> " + t.isAlive()); // 判断是否启动
}
static class MyThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName() + "运行，i = " + i);
}
}
}
}
守护线程
在 Java 程序中，只要前台有一个线程在运行，则整个 Java 进程就不会消失，因此此时能够设置一个守护线程，这样即便 Java 进程结束了，此守护线程依然会继续执行。可使用 setDaemon() 方法设置线程为守护线程；可使用 isDaemon() 方法判断线程是否为守护线程。
public class ThreadDaemonDemo {
public static void main(String[] args) {
Thread t = new Thread(new MyThread(), "线程");
t.setDaemon(true); // 此线程在后台运行
System.out.println("线程 t 是不是守护进程：" + t.isDaemon());
t.start(); // 启动线程
}
static class MyThread implements Runnable {
@Override
public void run() {
while (true) {
System.out.println(Thread.currentThread().getName() + "在运行。");
}
}
}
}
设置/获取线程优先级
在 Java 中，全部线程在运行前都会保持在就绪状态，那么此时，哪一个线程优先级高，哪一个线程就有可能被先执行。
public class ThreadPriorityDemo {
public static void main(String[] args) {
System.out.println("主方法的优先级：" + Thread.currentThread().getPriority());
System.out.println("MAX_PRIORITY = " + Thread.MAX_PRIORITY);
System.out.println("NORM_PRIORITY = " + Thread.NORM_PRIORITY);
System.out.println("MIN_PRIORITY = " + Thread.MIN_PRIORITY);
Thread t1 = new Thread(new MyThread(), "线程A"); // 实例化线程对象
Thread t2 = new Thread(new MyThread(), "线程B"); // 实例化线程对象
Thread t3 = new Thread(new MyThread(), "线程C"); // 实例化线程对象
t1.setPriority(Thread.MIN_PRIORITY); // 优先级最低
t2.setPriority(Thread.MAX_PRIORITY); // 优先级最低
t3.setPriority(Thread.NORM_PRIORITY); // 优先级最低
t1.start(); // 启动线程
t2.start(); // 启动线程
t3.start(); // 启动线程
}
static class MyThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(500); // 线程休眠
} catch (InterruptedException e) {
e.printStackTrace();
}
// 取得当前线程的名字
String out =
Thread.currentThread().getName() + "，优先级：" + Thread.currentThread().getPriority() + "，运行：i = " + i;
System.out.println(out);
}
}
}
}
线程间通讯
wait/notify/notifyAll
wait、notify、notifyAll 是 Object 类中的方法。
wait- 线程自动释放其占有的对象锁，并等待 notify。notify- 唤醒一个正在 wait 当前对象锁的线程，并让它拿到对象锁。notifyAll- 唤醒全部正在 wait 前对象锁的线程。
生产者、消费者示例：
public class ThreadWaitNotifyDemo02 {
private static final int QUEUE_SIZE = 10;
private static final PriorityQueue<Integer> queue = new PriorityQueue<>(QUEUE_SIZE);
public static void main(String[] args) {
new Producer("生产者A").start();
new Producer("生产者B").start();
new Consumer("消费者A").start();
new Consumer("消费者B").start();
}
static class Consumer extends Thread {
Consumer(String name) {
super(name);
}
@Override
public void run() {
while (true) {
synchronized (queue) {
while (queue.size() == 0) {
try {
System.out.println("队列空，等待数据");
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
queue.notifyAll();
}
}
queue.poll(); // 每次移走队首元素
queue.notifyAll();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 从队列取走一个元素，队列当前有：" + queue.size() + "个元素");
}
}
}
}
static class Producer extends Thread {
Producer(String name) {
super(name);
}
@Override
public void run() {
while (true) {
synchronized (queue) {
while (queue.size() == QUEUE_SIZE) {
try {
System.out.println("队列满，等待有空余空间");
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
queue.notifyAll();
}
}
queue.offer(1); // 每次插入一个元素
queue.notifyAll();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 向队列取中插入一个元素，队列当前有：" + queue.size() + "个元素");
}
}
}
}
}
线程的礼让
在线程操做中，可使用 Thread.yield() 方法将一个线程的操做暂时让给其余线程执行。
public class ThreadYieldDemo {
public static void main(String[] args) {
MyThread t = new MyThread();
new Thread(t, "线程A").start();
new Thread(t, "线程B").start();
}
static class MyThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "运行，i = " + i);
if (i == 2) {
System.out.print("线程礼让：");
Thread.yield();
}
}
}
}
}
线程的强制执行
在线程操做中，可使用 join() 方法让一个线程强制运行，线程强制运行期间，其余线程没法运行，必须等待此线程完成以后才能够继续执行。
public class ThreadJoinDemo {
public static void main(String[] args) {
MyThread mt = new MyThread(); // 实例化Runnable子类对象
Thread t = new Thread(mt, "mythread"); // 实例化Thread对象
t.start(); // 启动线程
for (int i = 0; i < 50; i++) {
if (i > 10) {
try {
t.join(); // 线程强制运行
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Main 线程运行 --> " + i);
}
}
static class MyThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println(Thread.currentThread().getName() + " 运行，i = " + i); // 取得当前线程的名字
}
}
}
}
线程的休眠
直接使用 Thread.sleep() 方法便可实现休眠。
public class ThreadSleepDemo {
public static void main(String[] args) {
new Thread(new MyThread("线程A", 1000)).start();
new Thread(new MyThread("线程A", 2000)).start();
new Thread(new MyThread("线程A", 3000)).start();
}
static class MyThread implements Runnable {
private String name;
private int time;
private MyThread(String name, int time) {
this.name = name; // 设置线程名称
this.time = time; // 设置休眠时间
}
@Override
public void run() {
try {
Thread.sleep(this.time); // 休眠指定的时间
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.name + "线程，休眠" + this.time + "毫秒。");
}
}
}
ThreadLocal
ThreadLocal，不少地方叫作线程本地变量，也有些地方叫作线程本地存储，其实意思差很少。可能不少朋友都知道 ThreadLocal 为变量在每一个线程中都建立了一个副本，那么每一个线程能够访问本身内部的副本变量。
源码
ThreadLocal 的主要方法：
public class ThreadLocal<T> {
public T get() {}
public void remove() {}
public void set(T value) {}
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {}
}
- get()方法是用来获取 ThreadLocal 在当前线程中保存的变量副本。
- set()用来设置当前线程中变量的副本。
- remove()用来移除当前线程中变量的副本。
- initialValue()是一个 protected 方法，通常是用来在使用时进行重写的，它是一个延迟加载方法，下面会详细说明。
get() 源码实现
get 源码
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
- 取得当前线程。
- 经过 getMap() 方法获取 ThreadLocalMap。
- 成功，返回 value；失败，返回 setInitialValue()。
ThreadLocalMap 源码实现
ThreadLocalMap 源码
ThreadLocalMap 是 ThreadLocal 的一个内部类。
ThreadLocalMap 的 Entry 继承了 WeakReference，而且使用 ThreadLocal 做为键值。
setInitialValue 源码实现
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
若是 map 不为空，就设置键值对；为空，再建立 Map，看一下 createMap 的实现：
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocal 源码小结
至此，可能大部分朋友已经明白了 ThreadLocal 是如何为每一个线程建立变量的副本的：
- 在每一个线程 Thread 内部有一个 ThreadLocal.ThreadLocalMap 类型的成员变量 threadLocals，这个 threadLocals 就是用来存储实际的变量副本的，键值为当前 ThreadLocal 变量，value 为变量副本（即 T 类型的变量）。
- 在 Thread 里面，threadLocals 为空，当经过 ThreadLocal 变量调用 get()方法或者 set()方法，就会对 Thread 类中的 threadLocals 进行初始化，而且以当前 ThreadLocal 变量为键值，以 ThreadLocal 要保存的副本变量为 value，存到 threadLocals。
- 在当前线程里面，若是要使用副本变量，就能够经过 get 方法在 threadLocals 里面查找。
示例
ThreadLocal 最多见的应用场景为用于解决数据库链接、Session 管理等问题。
示例 - 数据库链接
private static ThreadLocal<Connection> connectionHolder
= new ThreadLocal<Connection>() {
public Connection initialValue() {
return DriverManager.getConnection(DB_URL);
}
};
public static Connection getConnection() {
return connectionHolder.get();
}
示例 - Session 管理
private static final ThreadLocal threadSession = new ThreadLocal();
public static Session getSession() throws InfrastructureException {
Session s = (Session) threadSession.get();
try {
if (s == null) {
s = getSessionFactory().openSession();
threadSession.set(s);
}
} catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
return s;
}
管道输入/输出流
管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不一样之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。 管道输入/输出流主要包括了以下 4 种具体实现：PipedOutputStream、PipedInputStream、PipedReader 和 PipedWriter，前两种面向字节，然后两种面向字符。
public class Piped {
public static void main(String[] args) throws Exception {
PipedWriter out = new PipedWriter();
PipedReader in = new PipedReader();
// 将输出流和输入流进行链接，不然在使用时会抛出IOException
out.connect(in);
Thread printThread = new Thread(new Print(in), "PrintThread");
printThread.start();
int receive = 0;
try {
while ((receive = System.in.read()) != -1) {
out.write(receive);
}
} finally {
out.close();
}
}
static class Print implements Runnable {
private PipedReader in;
Print(PipedReader in) {
this.in = in;
}
public void run() {
int receive = 0;
try {
while ((receive = in.read()) != -1) {
System.out.print((char) receive);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
FAQ
start() 和 run() 有什么区别？能够直接调用 Thread 类的 run() 方法么？
run() 方法是线程的执行体。
start() 方法会启动线程，而后 JVM 会让这个线程去执行 run() 方法。
能够直接调用 Thread 类的 run() 方法么？
- 能够。可是若是直接调用 Thread 的 run()方法，它的行为就会和普通的方法同样。
- 为了在新的线程中执行咱们的代码，必须使用 Thread.start()方法。
sleep()、yield()、join() 方法有什么区别？为何 sleep()和 yield()方法是静态的？
- yield()
- yield() 方法可让当前正在执行的线程暂停，但它不会阻塞该线程，它只是将该线程从 Running 状态转入 Runnable 状态。
- 当某个线程调用了 yield() 方法暂停以后，只有优先级与当前线程相同，或者优先级比当前线程更高的处于就绪状态的线程才会得到执行的机会。
- sleep()
- sleep() 方法须要指定等待的时间，它可让当前正在执行的线程在指定的时间内暂停执行，进入 Blocked 状态。
- 该方法既可让其余同优先级或者高优先级的线程获得执行的机会，也可让低优先级的线程获得执行机会。
- 可是， sleep() 方法不会释放“锁标志”，也就是说若是有 synchronized 同步块，其余线程仍然不能访问共享数据。
- join()
- join() 方法会使当前线程转入 Blocked 状态，等待调用 join() 方法的线程结束后才能继续执行。
参考阅读：Java 线程中 yield 与 join 方法的区别 参考阅读：sleep()，wait()，yield()和 join()方法的区别
为何 sleep() 和 yield() 方法是静态的
- Thread 类的 sleep() 和 yield() 方法将处理 Running 状态的线程。因此在其余处于非 Running 状态的线程上执行这两个方法是没有意义的。这就是为何这些方法是静态的。它们能够在当前正在执行的线程中工做，并避免程序员错误的认为能够在其余非运行线程调用这些方法。
Java 的线程优先级如何控制？高优先级的 Java 线程必定先执行吗？
- Java 中的线程优先级如何控制
- Java 中的线程优先级的范围是 [1,10]，通常来讲，高优先级的线程在运行时会具备优先权。能够经过
thread.setPriority(Thread.MAX_PRIORITY)的方式设置，默认优先级为 5。
- Java 中的线程优先级的范围是 [1,10]，通常来讲，高优先级的线程在运行时会具备优先权。能够经过
- 高优先级的 Java 线程必定先执行吗
- 即便设置了线程的优先级，也没法保证高优先级的线程必定先执行。
- 缘由：这是由于线程优先级依赖于操做系统的支持，然而，不一样的操做系统支持的线程优先级并不相同，不能很好的和 Java 中线程优先级一一对应。
- 结论：Java 线程优先级控制并不可靠。
什么是守护线程？为何要用守护线程？如何建立守护线程？
- 什么是守护线程
- 守护线程（Daemon Thread）是在后台执行而且不会阻止 JVM 终止的线程。
- 与守护线程（Daemon Thread）相反的，叫用户线程（User Thread），也就是非守护线程。
- 为何要用守护线程
- 守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。典型的应用就是垃圾回收器。
- 如何建立守护线程
- 使用 thread.setDaemon(true) 能够设置 thread 线程为守护线程。
- 注意点：
- 正在运行的用户线程没法设置为守护线程，因此 thread.setDaemon(true) 必须在 thread.start() 以前设置，不然会抛出 llegalThreadStateException 异常；
- 一个守护线程建立的子线程依然是守护线程。
- 不要认为全部的应用均可以分配给 Daemon 来进行服务，好比读写操做或者计算逻辑。
参考阅读：Java 中守护线程的总结
为何线程通讯的方法 wait(), notify()和 notifyAll()被定义在 Object 类里？
Java 的每一个对象中都有一个锁(monitor，也能够成为监视器) 而且 wait()，notify()等方法用于等待对象的锁或者通知其余线程对象的监视器可用。在 Java 的线程中并无可供任何对象使用的锁和同步器。这就是为何这些方法是 Object 类的一部分，这样 Java 的每个类都有用于线程间通讯的基本方法
为何 wait(), notify()和 notifyAll()必须在同步方法或者同步块中被调用？
当一个线程须要调用对象的 wait()方法的时候，这个线程必须拥有该对象的锁，接着它就会释放这个对象锁并进入等待状态直到其余线程调用这个对象上的 notify()方法。一样的，当一个线程须要调用对象的 notify()方法时，它会释放这个对象的锁，以便其余在等待的线程就能够获得这个对象锁。因为全部的这些方法都须要线程持有对象的锁，这样就只能经过同步来实现，因此他们只能在同步方法或者同步块中被调用。
免费Java资料须要本身领取，涵盖了Java、Redis、MongoDB、MySQL、Zookeeper、Spring Cloud、Dubbo/Kafka、Hadoop、Hbase、Flink等高并发分布式、大数据、机器学习等技术。
传送门： https://mp.weixin.qq.com/s/JzddfH-7yNudmkjT0IRL8Q
相关文章
- 1. Java线程小刀牛试
- 2. Java Flight Recorder小试牛刀
- 3. Java注解，小试牛刀
- 4. rsocket-java小试牛刀
- 5. C# 多线程小试牛刀
- 6. 小试牛刀
- 7. Django:牛刀小试
- 8. 小试牛刀(4)
- 9. Maven小试牛刀
- 10. handle_detector 小试牛刀
- 更多相关文章...
- • C# 多线程 - C#教程
- • Lua 调试(Debug) - Lua 教程
- • Java 8 Stream 教程
- • YAML 入门教程
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Java线程小刀牛试
- 2. Java Flight Recorder小试牛刀
- 3. Java注解，小试牛刀
- 4. rsocket-java小试牛刀
- 5. C# 多线程小试牛刀
- 6. 小试牛刀
- 7. Django:牛刀小试
- 8. 小试牛刀(4)
- 9. Maven小试牛刀
- 10. handle_detector 小试牛刀