一、基础篇
进程是系统进行资源分配和调动的基本单位，一个进程中至少有一个线程，进程中多个线程共享进程的资源。
线程是进程中的一个实体，线程是不会独立存在的，没有进程就没有线程。
对于CPU资源比较特殊，线程才是CPU分配的基本单位。
main函数启动->JVM进程->main函数线程称为主线程
内存与线程
内存与线程的关心，主要指JVM内存模型与线程之间的关系，它也是线程安全问题的主要诱因。
使用JDK工具观察线程
jcmd
jstack
jvisualVM
jconsole
线程创建的三种方法
Account类
package com.aidata.concurrency; public class Account { private String accountNo; private String accountName; private boolean valid; public Account(){} public Account(String accountNo, String accountName, boolean valid){ this.accountNo = accountNo; this.accountName = accountName; this.valid = valid; } public String getAccountNo() { return accountNo; } public void setAccountNo(String accountNo) { this.accountNo = accountNo; } public String getAccountName() { return accountName; } public void setAccountName(String accountName) { this.accountName = accountName; } public boolean isValid() { return valid; } public void setValid(boolean valid) { this.valid = valid; } @Override public String toString() { return "Account{" + "accountNo='" + accountNo + '\'' + ", accountName='" + accountName + '\'' + ", valid=" + valid + '}'; } }
继承Thread
package com.aidata.concurrency; // 1.继承Thread public class CreateThreadExtendsThread extends Thread { private Account account; public CreateThreadExtendsThread(){} public CreateThreadExtendsThread(Account account){ this.account = account; } public void setAccount(Account account){ this.account = account; } // 2.覆写run方法 public void run(){ System.out.println(this.getName() + " Account's information:" + this.account +"," + this.getState()); } public static void main(String[] args) { Account account = new Account("999999", "Wang", true); CreateThreadExtendsThread thread0 = new CreateThreadExtendsThread(); // 线程传参方式1 thread0.setAccount(account); // 线程没有调用start，状态是NEW System.out.println(thread0.getState()); // 调用start()方法会执行线程中的run()方法，状态是RUNNABLE thread0.start(); try { // 休眠一秒钟，保证thread0执行完 Thread.sleep(1000); }catch (Exception e){ e.printStackTrace(); } //TERMINATED System.out.println(thread0.getState()); // 线程传参方式2 CreateThreadExtendsThread thread1 = new CreateThreadExtendsThread(account); thread1.start(); } }
结果
NEW Thread-0 Account's information:Account{accountNo='999999', accountName='Wang', valid=true},RUNNABLE TERMINATED Thread-1 Account's information:Account{accountNo='999999', accountName='Wang', valid=true},RUNNABLE
如果注释掉上面休眠的代码，结果
NEW
RUNNABLE
Thread-1 Account's information:Account{accountNo='999999', accountName='Wang', valid=true},RUNNABLE
Thread-0 Account's information:Account{accountNo='999999', accountName='Wang', valid=true},RUNNABLE
优点：简单，Thread类中有大量的方法，可以通过this获得线程的丰富信息
缺点：Java是单继承的，继承了Thread就无法继承其他类了
实现Runnable接口
@FunctionalInterface public interface Runnable { /** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the thread causes the object's * <code>run</code> method to be called in that separately executing * thread. * <p> * The general contract of the method <code>run</code> is that it may * take any action whatsoever. * * @see java.lang.Thread#run() */ public abstract void run(); }
实现接口
package com.aidata.concurrency; public class CreateThreadImplementsRunnable implements Runnable{ private Account account; public CreateThreadImplementsRunnable(){} public CreateThreadImplementsRunnable(Account account){ this.account = account; } public void setAccount(Account account) { this.account = account; } public void run() { // 接口中只有run()方法，要获取名称使用下面的方法 System.out.println(Thread.currentThread().getName() + " Account's information: " + this.account); } public static void main(String[] args) { final Account account = new Account("888888", "Wang", true); CreateThreadImplementsRunnable thread0 = new CreateThreadImplementsRunnable(); // 创建线程方式1 thread0.setAccount(account); new Thread(thread0).start(); // 创建线程方式2 CreateThreadImplementsRunnable thread1 = new CreateThreadImplementsRunnable(account); new Thread(thread1).start(); // 创建线程方式3 接口方便之处是可以使用匿名内部类来实现 new Thread(new Runnable() { public void run() { System.out.println(account); } }).start(); } }
接口中没有start()方法，必须借助Thread类才能启动，以及获取线程相关的信息。
实现Callable接口
@FunctionalInterface public interface Callable<V> { /** * Computes a result, or throws an exception if unable to do so. * * @return computed result * @throws Exception if unable to compute a result */ V call() throws Exception; }
实现接口
package com.aidata.concurrency; import java.util.concurrent.Callable; import java.util.concurrent.FutureTask; public class CreateThreadImplementsCallable implements Callable<Account> { private Account account; public CreateThreadImplementsCallable(){} public CreateThreadImplementsCallable(Account account){ this.account = account; } public void setAccount(Account account) { this.account = account; } // 返回值和泛型设置有关 public Account call() throws Exception { System.out.println(Thread.currentThread().getName() + " Account's information: " + this.account); this.account.setValid(false); Thread.sleep(3000); return this.account; } public static void main(String[] args) { Account account = new Account("66666666", "Wang", true); CreateThreadImplementsCallable call = new CreateThreadImplementsCallable(); call.setAccount(account); // 异步阻塞模型 FutureTask<Account> ft = new FutureTask<Account>(call); new Thread(ft).start(); try { // get得到的值类型和泛型有关 Account result = ft.get(); System.out.println("result:" + result); } catch (Exception e){ e.printStackTrace(); } } }
结果
Thread-0 Account's information: Account{accountNo='66666666', accountName='Wang', valid=true}
result:Account{accountNo='66666666', accountName='Wang', valid=false}
三秒后，才会打印result，因为
Account result = ft.get();
是阻塞的，线程中的执行完，即休眠三秒后，才继续执行下面的
JOIN等待线程执行终止
使用场景：等待线程执行终止之后，继续执行
易混淆知识点：join方法为Thread类直接提供的方法，而wait和notify为Object类中的方法
可以使用CountDownLatch达到同样的效果
IDEA 双击shift，搜索Objec，使用快捷键Alt+7
Thread的三个join方法
public final void join() throws InterruptedException { join(0); } public final synchronized void join(long millis) throws InterruptedException { long base = System.currentTimeMillis(); long now = 0; if (millis < 0) { throw new IllegalArgumentException("timeout value is negative"); } if (millis == 0) { while (isAlive()) { wait(0); } } else { while (isAlive()) { long delay = millis - now; if (delay <= 0) { break; }
// 还是使用的Object的wait方法 wait(delay); now = System.currentTimeMillis() - base; } } }
// nanos 纳秒值，四舍五入的概念，0-500000之间不管，只用毫秒，500000-999999就毫秒加1 public final synchronized void join(long millis, int nanos) throws InterruptedException { if (millis < 0) { throw new IllegalArgumentException("timeout value is negative"); } if (nanos < 0 || nanos > 999999) { throw new IllegalArgumentException( "nanosecond timeout value out of range"); } if (nanos >= 500000 || (nanos != 0 && millis == 0)) { millis++; } join(millis); }
例子
package com.aidata.concurrency; public class JoinDemo { public static void main(String[] args) { Thread t1 = new Thread(new Runnable() { public void run() { try { Thread.sleep(2000); }catch (InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " run over!"); } }); Thread t2 = new Thread(new Runnable() { public void run() { try{ Thread.sleep(2000); }catch (InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " run over!"); } }); t1.start(); t2.start(); System.out.println(Thread.currentThread().getName() + " wait " + t1.getName() + " and " + t2.getName() + " run over!"); // 打开和关闭此段注释观察执行效果来理解join的用途 try{ t1.join(); t2.join(); }catch (InterruptedException e){ e.printStackTrace(); } // 打开和关闭此段注释观察执行效果来理解join的用途 // try{ // t1.join(1000); // t2.join(1000); // // t1.join(1000, 500); // // t2.join(1000, 500); // }catch (InterruptedException e){ // e.printStackTrace(); // } System.out.println("final " + t1.getName() + " and " + t2.getName() + " run over!"); System.out.println("t1's state: " + t1.getState()); System.out.println("t2's state: " + t2.getState()); } }
结果
main wait Thread-0 and Thread-1 run over! Thread-0 run over! Thread-1 run over! final Thread-0 and Thread-1 run over! t1's state: TERMINATED t2's state: TERMINATED
运行到
t1.join();
t2.join();
时，主线程会阻塞，等待t1、t2执行完，再执行
System.out.println("final " + t1.getName() + " and " + t2.getName() + " run over!");
如果注释掉上面的两个join，结果为
main wait Thread-0 and Thread-1 run over! final Thread-0 and Thread-1 run over! t1's state: TIMED_WAITING t2's state: TIMED_WAITING Thread-0 run over! Thread-1 run over!
t1、t2不会阻塞主线程，由于休眠，线程里的内容最后才执行完，TIMED_WAITING带有时间的等待，即在执行sleep
sleep方法解析
Thread类中的一个静态方法，暂时让出执行权，不参与CPU调度，但是不释放锁。时间到了就进入就绪状态，一旦获取到CPU时间片，则继续执行。
public static native void sleep(long millis) throws InterruptedException; /** * Causes the currently executing thread to sleep (temporarily cease * execution) for the specified number of milliseconds plus the specified * number of nanoseconds, subject to the precision and accuracy of system * timers and schedulers. The thread does not lose ownership of any * monitors. * * @param millis * the length of time to sleep in milliseconds * * @param nanos * {@code 0-999999} additional nanoseconds to sleep * * @throws IllegalArgumentException * if the value of {@code millis} is negative, or the value of * {@code nanos} is not in the range {@code 0-999999} * * @throws InterruptedException * if any thread has interrupted the current thread. The * <i>interrupted status</i> of the current thread is * cleared when this exception is thrown. */ public static void sleep(long millis, int nanos) throws InterruptedException { if (millis < 0) { throw new IllegalArgumentException("timeout value is negative"); } if (nanos < 0 || nanos > 999999) { throw new IllegalArgumentException( "nanosecond timeout value out of range"); } if (nanos >= 500000 || (nanos != 0 && millis == 0)) { millis++; } sleep(millis); }
一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现，比如C。这个特征并非java所特有，很多其它的编程语言都有这一机制，比如在C＋＋中，你可以用extern "C"告知C＋＋编译器去调用一个C的函数。 "A native method is a Java method whose implementation is provided by non-java code." 在定义一个native method时，并不提供实现体（有些像定义一个java interface），因为其实现体是由非java语言在外面实现的。
用异常打断sleep
package com.aidata.concurrency; public class SleepDemo { public static void main(String[] args) { final Object lock = new Object(); Thread t1 = new Thread(new Runnable() { public void run() { synchronized (lock){ System.out.println(Thread.currentThread().getName() + " get Lock, sleeping"); } try{ Thread.sleep(2000); }catch (Exception e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " sleep over and run over!"); } }); Thread t2 = new Thread(new Runnable() { public void run() { synchronized (lock){ System.out.println(Thread.currentThread().getName() + " get Lock, sleeping"); } try{ Thread.sleep(2000); }catch (Exception e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " sleep over and run over!"); } }); t1.start(); t2.start(); t1.interrupt(); } }
结果
Thread-0 get Lock, sleeping Thread-1 get Lock, sleeping java.lang.InterruptedException: sleep interrupted at java.lang.Thread.sleep(Native Method) at com.aidata.concurrency.SleepDemo$1.run(SleepDemo.java:14) at java.lang.Thread.run(Thread.java:748) Thread-0 sleep over and run over! Thread-1 sleep over and run over!
Thread-0没有sleep，而是抛出异常后直接打印了 Thread-0 sleep over and run over!
没有interrupt结果
Thread-0 get Lock, sleeping Thread-1 get Lock, sleeping Thread-0 sleep over and run over! Thread-1 sleep over and run over!
yield方法
不建议使用
Thread类中的静态native方法，让出剩余的时间片，本身进入就绪状态，CPU再次调度还可能调度到本线程。
易混淆知识点：sleep是在一段时间内进入阻塞状态，CPU不会调度它。而yield是让出执行权，本身处于就绪状态，CPU还可能立即调度它。
/** * A hint to the scheduler that the current thread is willing to yield * its current use of a processor. The scheduler is free to ignore this * hint. * * <p> Yield is a heuristic attempt to improve relative progression * between threads that would otherwise over-utilise a CPU. Its use * should be combined with detailed profiling and benchmarking to * ensure that it actually has the desired effect. * * <p> It is rarely appropriate to use this method. It may be useful * for debugging or testing purposes, where it may help to reproduce * bugs due to race conditions. It may also be useful when designing * concurrency control constructs such as the ones in the * {@link java.util.concurrent.locks} package. */ public static native void yield();
例子
package com.aidata.concurrency; public class YieldDmo0 extends Thread{ @Override public void run() { System.out.println(this.getName() + " yield"); this.yield(); System.out.println(this.getName() + " run over"); } public static void main(String[] args) { for (int i=0; i<1000; i++){ YieldDmo0 demo = new YieldDmo0(); demo.start(); } } }
会出现这种连城一片的形式
... Thread-671 yield Thread-673 yield Thread-672 yield Thread-673 run over Thread-671 run over Thread-672 run over ...
加锁后
package com.aidata.concurrency; // yield 让出执行权，但是不释放锁 public class YieldDmo1 extends Thread{ // 共享锁 public static Object lock = new Object(); @Override public void run() { synchronized (lock){ System.out.println(this.getName() + " yield"); this.yield(); System.out.println(this.getName() + " run over"); } } public static void main(String[] args) { for (int i=0; i<1000; i++){ YieldDmo1 demo = new YieldDmo1(); demo.start(); } } }
成对出现
Thread-0 yield Thread-0 run over Thread-5 yield Thread-5 run over ...
yield 不释放锁，每个线程都执行完才能执行另外的线程
wait会使线程进入阻塞状态，且是释放锁的。wait方法结合synchronized关键字、notify方法使用。
package com.aidata.concurrency; // yield 让出执行权，但是不释放锁 public class YieldDmo1 extends Thread{ // 共享锁 public static Object lock = new Object(); @Override public void run() { synchronized (lock){ System.out.println(this.getName() + " yield"); // this.yield(); // 使用wait方法来做对比，查看释放锁与不释放锁的区别 try{ lock.wait(); }catch (InterruptedException e){ e.printStackTrace(); } System.out.println(this.getName() + " run over"); } } public static void main(String[] args) { for (int i=0; i<1000; i++){ YieldDmo1 demo = new YieldDmo1(); demo.start(); } // 配合wait使用看效果 synchronized (lock){ lock.notifyAll(); } } }
上面全是yield，执行notifyAll()后下面全是run over
... Thread-994 yield Thread-995 yield Thread-996 yield Thread-999 yield Thread-996 run over Thread-995 run over Thread-994 run over Thread-993 run over Thread-992 run over Thread-991 run over ...
每次线程执行，执行第一个打印后，执行wait()方法都会阻塞，并释放锁给另一个线程，另一个线程也执行第一句打印，执行wait()释放锁给另一个线程...
直到执行notifyAll()方法，所有线程结束阻塞，开始执行剩下的语句。
线程中断方法
Interrupt相关方法
线程中断是线程间的一种协作模式，通过设置线程中断标志来实现，线程根据这个标志来自行处理。
Thread中相关方法
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(); } /** * Tests whether the current thread has been interrupted. The * <i>interrupted status</i> of the thread is cleared by this method. In * other words, if this method were to be called twice in succession, the * second call would return false (unless the current thread were * interrupted again, after the first call had cleared its interrupted * status and before the second call had examined it). * * <p>A thread interruption ignored because a thread was not alive * at the time of the interrupt will be reflected by this method * returning false. * * @return <code>true</code> if the current thread has been interrupted; * <code>false</code> otherwise. * @see #isInterrupted() * @revised 6.0 */ public static boolean interrupted() { return currentThread().isInterrupted(true); // true，改变中断标记 } public boolean isInterrupted() { return isInterrupted(false); // false，返回原有的中断标记，不改变，true就是true，false就是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); private native void interrupt0();
例子
package com.aidata.concurrency; // isInterrupted和interrupt的使用 public class TnterruptDemo0 { public static void main(String[] args) { Thread t1 = new Thread(new Runnable() { public void run() { // 2.开始执行循环 for (int i=0; i<99999; i++){ // 3.判断是否为中断状态，如果是中断则退出循环 if (Thread.currentThread().isInterrupted()){ System.out.println(Thread.currentThread().getName() + " interrupted"); break; } System.out.println(Thread.currentThread().getName() + i + " is running"); } } }); // 1.启动 t1.start(); // 4.调用中断，是否会中断死循环? t1.interrupt(); // 把t1线程的中断标记设置成了true try { t1.join(); }catch (InterruptedException e){ e.printStackTrace(); } System.out.println(t1.getState()); } }
结果
Thread-0 interrupted
TERMINATED
也就是说线程里执行了
if (Thread.currentThread().isInterrupted()){ System.out.println(Thread.currentThread().getName() + " interrupted"); break; }
如果去掉上面的判断，则
... Thread-099996 is running Thread-099997 is running Thread-099998 is running TERMINATED
也就是说，会不会被打断是取决于上面的判断的，而非
// 4.调用中断，是否会中断死循环? t1.interrupt(); // 把t1线程的中断标记设置成了true
它只是为t1打了一个中断标签，并没有真的去打断，你可以捕获并实现相关逻辑
public static boolean interrupted() { return currentThread().isInterrupted(true); // true，改变中断标记 } public boolean isInterrupted() { return isInterrupted(false); // false，返回原有的中断标记，不改变，true就是true，false就是false }
isInterrupted() 会返回中断标记，不会进行修改
interrupted() 会修改中断标记
package com.aidata.concurrency; public class InterruptDemo1 { public static void main(String[] args) { Thread t1 = new Thread(new Runnable() { public void run() { // 3.条件为!true=false退出循环 while (!Thread.currentThread().interrupted()){ } // 4.这里输出的是什么true还是false System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().isInterrupted()); } }); // 1.开始 t1.start(); // 2.中断标记设置为true t1.interrupt(); try{ t1.join(); }catch (InterruptedException e){ e.printStackTrace(); } System.out.println("main is run over"); } }
结果
Thread-0:false main is run over
没有进入while循环，则 Thread.currentThread().interrupted() 为true
而下面打印中 Thread.currentThread().isInterrupted() 结果为false，说明interrupted() 会修改当前线程的中断标记
while循环的写法应该是
while (!Thread.interrupted()){ }
因为interrupted是静态方法，只对当前的线程生效，所以结果是一样的
while判断更换为 !Thread.currentThread().isInterrupted()
package com.aidata.concurrency; public class InterruptDemo1 { public static void main(String[] args) { Thread t1 = new Thread(new Runnable() { public void run() { // 3.条件为!true=false退出循环 // 5.如果这里更换为Thread.currentThread().isInterrupted() while (!Thread.currentThread().isInterrupted()){ } // 4.这里输出的是什么true还是false // 6.这里输出的是什么true还是false System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().isInterrupted()); } }); // 1.开始 t1.start(); // 2.中断标记设置为true t1.interrupt(); try{ t1.join(); }catch (InterruptedException e){ e.printStackTrace(); } System.out.println("main is run over"); } }
结果为
Thread-0:true main is run over
isInterrupted() 会返回中断标记，不会进行修改
中断异常
join方法和sleep一样会抛出中断异常
Thread.interrupt()方法中断线程时，join方法的异常只能在自身线程才能被捕获,在其它线程调用时无法被捕获：
package com.aidata.concurrency; public class JoninDemo2 { public static void main(String[] args) { final Thread t0 = new Thread(new Runnable() { public void run() { System.out.println("t0 is running"); System.out.println(Thread.currentThread().getName() + " run over!"); } }); Thread t1 = new Thread(new Runnable() { public void run() { System.out.println("t1 is runnng"); try { t0.start(); Thread.currentThread().interrupt(); t0.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " run over!"); } }); t1.start(); } }
t0线程运行在t1线程中，t1线程interrupt后，遇到t0.join()会抛出异常，也就是这个t0.join()没有运行，即没有阻塞等待t0完成
结果：
t1 is runnng t0 is running Thread-0 run over! java.lang.InterruptedException at java.lang.Object.wait(Native Method) at java.lang.Thread.join(Thread.java:1252) at java.lang.Thread.join(Thread.java:1326) at com.aidata.concurrency.JoninDemo2$2.run(JoninDemo2.java:20) at java.lang.Thread.run(Thread.java:748) Thread-1 run over!
package com.aidata.concurrency; public class JoinDemo1 { public static void main(String[] args) { // 创建t0线程 final Thread t0 = new Thread(new Runnable() { public void run() { System.out.println("t0 will sleep 00000000000000000000000"); try { Thread.sleep(2000*20); } catch (InterruptedException e) { e.printStackTrace(); System.out.println("sleep的异常"); } System.out.println(Thread.currentThread().getName() + " run over!"); } }); // 创建main线程 final Thread mainThread = Thread.currentThread(); Thread t1 = new Thread(new Runnable() { public void run() { System.out.println("in t1 now 1111111111111111111"); // 调用主线程的interrupt方法，开启中断标记，会影响主线中的join方法抛出异常，但是并不会阻碍t0线程的运行 mainThread.interrupt(); // 修改为t0.interrupt();观察效果，会影响t0线程的sleep方法抛出异常，让t0线程结束 // t0.interrupt(); System.out.println(mainThread.getName() + " interrupt!"); System.out.println(Thread.currentThread().getName() + " run over!"); } }); t0.start(); t1.start(); System.out.println(Thread.currentThread().getName() + " wait " + t0.getName() + " and " + t1.getName() + " run over!"); try { System.out.println("will run t0.join()-----------"); t0.join(); System.out.println("running t0.join()==========="); }catch (InterruptedException e){ e.printStackTrace(); System.out.println("t0.join的异常"); } System.out.println("final: " + t0.getName() + " and " + t1.getName() + " run over!"); System.out.println("t0's state: " + t0.getState()); System.out.println("t1's state: " + t1.getState()); System.out.println("main's state: " + mainThread.getState()); } }
结果
main wait Thread-0 and Thread-1 run over! will run t0.join()----------- in t1 now 1111111111111111111 t0 will sleep 00000000000000000000000 main interrupt! Thread-1 run over! java.lang.InterruptedException at java.lang.Object.wait(Native Method) at java.lang.Thread.join(Thread.java:1252) at java.lang.Thread.join(Thread.java:1326) at com.aidata.concurrency.JoinDemo1.main(JoinDemo1.java:42) t0.join的异常 final: Thread-0 and Thread-1 run over! t0's state: TIMED_WAITING t1's state: TERMINATED main's state: RUNNABLE
可知
先打印了
System.out.println(Thread.currentThread().getName() + " wait " + t0.getName() + " and " + t1.getName() + " run over!");
System.out.println("will run t0.join()-----------");
然后，线程t0和t1开始执行，to进行sleep，t1让主线程interrupt，t1执行完后，主线程的t0.join()开始执行，因为主线程被interrupt了，主线程中的子线程调用join会导致异常，但是该异常不会停止t0线程，to线程仍然执行，只是不join()了，也就是不阻塞执行，因此主线程中下面的打印语句都执行了，一直等到t0休眠结束，整个程序结束。
还可以t0.interrupt()，这会导致sleep抛出异常，导致t0结束
package com.aidata.concurrency; public class JoinDemo1 { public static void main(String[] args) { // 创建t0线程 final Thread t0 = new Thread(new Runnable() { public void run() { System.out.println("t0 will sleep 00000000000000000000000"); try { Thread.sleep(2000*20); } catch (InterruptedException e) { e.printStackTrace(); System.out.println("sleep的异常"); } System.out.println(Thread.currentThread().getName() + " run over!"); } }); // 创建main线程 final Thread mainThread = Thread.currentThread(); Thread t1 = new Thread(new Runnable() { public void run() { System.out.println("in t1 now 1111111111111111111");// 修改为t0.interrupt();观察效果，会影响t0线程的sleep方法抛出异常，让t0线程结束 t0.interrupt(); System.out.println(mainThread.getName() + " interrupt!"); System.out.println(Thread.currentThread().getName() + " run over!"); } }); t0.start(); t1.start(); System.out.println(Thread.currentThread().getName() + " wait " + t0.getName() + " and " + t1.getName() + " run over!"); System.out.println("final: " + t0.getName() + " and " + t1.getName() + " run over!"); System.out.println("t0's state: " + t0.getState()); System.out.println("t1's state: " + t1.getState()); System.out.println("main's state: " + mainThread.getState()); } }
结果
main wait Thread-0 and Thread-1 run over! t0 will sleep 00000000000000000000000 in t1 now 1111111111111111111 final: Thread-0 and Thread-1 run over! main interrupt! Thread-1 run over! t0's state: TIMED_WAITING t1's state: TERMINATED main's state: RUNNABLE java.lang.InterruptedException: sleep interrupted at java.lang.Thread.sleep(Native Method) at com.aidata.concurrency.JoinDemo1$1.run(JoinDemo1.java:12) at java.lang.Thread.run(Thread.java:748) sleep的异常 Thread-0 run over!
线程安全
可见性
安全性
package com.aidata.concurrency; class User{ private String name; private String pass; public User(String name, String pass){ this.name = name; this.pass = pass; } public void set(String name, String pass){ this.name = name; try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } this.pass = pass; System.out.println(Thread.currentThread().getName() + " -name=" + this.name + " pass=" + this.pass); } } /** * servlet是单利多线程的，Servlet本身并不是一个单例实现，只是容器加载的时候只实例化一次，所造成的单例现象 */ class UserServlet{ private User user; public UserServlet(){ user = new User("w", "123"); } public void setPass(String name, String pass){ user.set(name, pass); } } public class DemoThread00 { public static void main(String[] args) { final UserServlet us = new UserServlet(); new Thread(new Runnable() { public void run() { us.setPass("李四", "777"); } }).start(); new Thread(new Runnable() { public void run() { us.setPass("王五", "888"); } }).start(); } }
结果
Thread-0 -name=王五 pass=777
Thread-1 -name=王五 pass=888
两个都是王五，原因：
两个线程，操作同一个对象us
第一个线程
us.setPass("李四", "777");
实际调用了User的
public void set(String name, String pass){ this.name = name; try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } this.pass = pass; System.out.println(Thread.currentThread().getName() + " -name=" + this.name + " pass=" + this.pass); }
首先设定名字为李四，然后就休眠了5秒，此时第二个线程也操作us，设定名字为王五，也就是说进行了覆盖。5秒后，第一个线程继续工作，密码改为777，进行打印。
第二个线程睡眠5秒后，把密码改为888，进行打印。
线程安全与Synchronized
当多个线程访问某一个类、对象或方法时，这个类、对象或方法都能表现出与单线程执行时一致的行为，那么这个类、对象或方法是线程安全的。
线程安全问题是由全局变量和静态变量引起的。
若每个线程中全局变量、静态变量只有读操作，而无些操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都是需要考虑线程同步，否则的话就可能影响线程安全。
Synchronized的作用是加锁，所有的Synchronized方法都会顺序执行，这里指占用CPU的顺序。
Synchronized 方法执行方式：
- 首先尝试获得锁
- 如果获得锁，则执行Synchronized的方法体内容
- 如果无法获得锁则等待，并且不断的尝试去获得锁，一旦锁释放，则多个线程会同时去尝试获得锁，造成锁竞争问题
锁竞争问题，在高并发、线程数量高时会引起CPU占用居高不下，或直接宕机。
package com.aidata.concurrency; class User{ private String name; private String pass; public User(String name, String pass){ this.name = name; this.pass = pass; } public synchronized void set(String name, String pass){ this.name = name; try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } this.pass = pass; System.out.println(Thread.currentThread().getName() + " -name=" + this.name + " pass=" + this.pass); } } /** * servlet是单利多线程的，Servlet本身并不是一个单例实现，只是容器加载的时候只实例化一次，所造成的单例现象 */ class UserServlet{ private User user; public UserServlet(){ user = new User("w", "123"); } public void setPass(String name, String pass){ user.set(name, pass); } } public class DemoThread00 { public static void main(String[] args) { final UserServlet us = new UserServlet(); new Thread(new Runnable() { public void run() { us.setPass("李四", "777"); } }).start(); new Thread(new Runnable() { public void run() { us.setPass("王五", "888"); } }).start(); } }
加锁后，线程安全
Thread-0 -name=李四 pass=777
Thread-1 -name=王五 pass=888
对象锁和类锁
没有锁
package com.aidata.concurrency; public class DemoThread02 { private /*static*/ int count = 0; // 如果是static变量会怎么样？ public /*synchronized*/ /*static*/ void add(){ count++; try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ">count=" + count); } public static void main(String[] args) { final DemoThread02 thread0 = new DemoThread02(); final DemoThread02 thread1 = new DemoThread02(); Thread t0 = new Thread(new Runnable() { public void run() { thread0.add(); // 1.同一个对象，同一把锁 } }, "thread0"); Thread t1 = new Thread(new Runnable() { public void run() { thread0.add(); } }, "thread1"); t0.start(); t1.start(); } }
结果：
thread0>count=2
thread1>count=2
两个线程调用同一个对象的add方法
实现第一个线程，加1，count变为1，休眠1秒，第二个线程加1，count变为2，第一线程休眠完打印，第二个线程休眠完打印。
Synchronized作用在非静态方法上代表的对象锁，一个对象一个锁
package com.aidata.concurrency; public class DemoThread02 { private /*static*/ int count = 0; // 如果是static变量会怎么样？ public synchronized /*static*/ void add(){ count++; try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ">count=" + count); } public static void main(String[] args) { final DemoThread02 thread0 = new DemoThread02(); final DemoThread02 thread1 = new DemoThread02(); Thread t0 = new Thread(new Runnable() { public void run() { thread0.add(); // 1.同一个对象，同一把锁 } }, "thread0"); Thread t1 = new Thread(new Runnable() { public void run() { thread0.add(); // thread1.add(); // 1.同一个对象，同一把锁 } }, "thread1"); t0.start(); t1.start(); } }
同一个对象，对象锁，一个线程运行完，锁才给另一个线程，同一把锁互斥
结果
thread0>count=1
thread1>count=2
多个对象之间不会发送锁竞争
package com.aidata.concurrency; public class DemoThread02 { private /*static*/ int count = 0; // 如果是static变量会怎么样？ public synchronized /*static*/ void add(){ count++; try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ">count=" + count); } public static void main(String[] args) { final DemoThread02 thread0 = new DemoThread02(); final DemoThread02 thread1 = new DemoThread02(); Thread t0 = new Thread(new Runnable() { public void run() { thread0.add(); // 1.同一个对象，同一把锁 } }, "thread0"); Thread t1 = new Thread(new Runnable() { public void run() { thread1.add(); // 1.同一个对象，同一把锁 } }, "thread1"); t0.start(); t1.start(); } }
两个对象，分别加锁，不是同一把锁，并不会产生锁的互斥，没有关系
结果
thread1>count=1
thread0>count=1
Synchronized作用在静态方法上则升级为类锁，所有对象共享一把锁，存在锁竞争
package com.aidata.concurrency; public class DemoThread02 { private static int count = 0; // 如果是static变量会怎么样？ public synchronized static void add(){ count++; try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ">count=" + count); } public static void main(String[] args) { final DemoThread02 thread0 = new DemoThread02(); final DemoThread02 thread1 = new DemoThread02(); Thread t0 = new Thread(new Runnable() { public void run() { thread0.add(); // 1.同一个对象，同一把锁 } }, "thread0"); Thread t1 = new Thread(new Runnable() { public void run() { thread1.add(); // 1.同一个对象，同一把锁 } }, "thread1"); t0.start(); t1.start(); } }
类锁，所有对象共享一把锁，互斥，静态变量两个线程共享
结果
thread0>count=1
thread1>count=2
对象锁的同步和异步
同步：必须等待方法执行完毕，才能向下执行，共享资源访问的时候，为了保证线程安全，必须同步。
异步：不用等待其他方法执行完毕，即可立即执行，例如Ajax异步。
package com.aidata.concurrency; public class DemoThread03 { // 同步执行 public synchronized void print1(){ System.out.println(Thread.currentThread().getName() + ">hello!"); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } // 异步执行 public void print2(){ System.out.println(Thread.currentThread().getName()+">hello!"); } public static void main(String[] args) { final DemoThread03 thread = new DemoThread03(); Thread t0 = new Thread(new Runnable() { public void run() { thread.print1(); } }, "Thread0"); Thread t1 = new Thread(new Runnable() { public void run() { thread.print2(); } }, "Thread1"); t0.start(); t1.start(); } }
对象锁只针对synchronized修饰的方法生效、对象中所有synchronized方法都会同步执行 ，非synchronized方法异步执行
因此上面，没有等待三秒，t1线程直接运行了线程里的打印语句
脏读
由于同步和异步方法的执行个性，如果不从全局上进行并发设计很可能引起数据的不一致，也就是所谓脏读。
多个线程访问同一个资源，在一个线程修改数据的过程中，有另外的线程来读取数据，就好引起脏读：
private String name = "张三"; private String address = "大兴"; public synchronized void setVal(String name, String address){ this.name = name; try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } this.address = address; System.out.println("setVal最终结果：username = " + name + " ,address = " + address); } public void getVal(){ System.out.println("getVal方法得到：username = " + name + " ,address = " + address); } public static void main(String[] args) throws InterruptedException { final DemoThread04 dr = new DemoThread04(); Thread t0 = new Thread(new Runnable() { public void run() { dr.setVal("李四", "昌平"); } }); t0.start(); Thread.sleep(1000); dr.getVal(); } }
setVal加锁了，但是getVal没有加锁，t0线程执行，修改name后会休眠两秒，而主线程休眠一秒后就调用了getVal()方法，此时只改了name，address还没改，产生了脏读。
结果
getVal方法得到：username = 李四 ,address = 大兴
setVal最终结果：username = 李四 ,address = 昌平
为了避免脏读，我们一定要保证数据修改操作的原子性，并对读取操作也要进行同步控制。
即不能让其他线程写，也不能让其他线程读，将getVal()也加上synchronized关键字即可。
结果为
setVal最终结果：username = 李四 ,address = 昌平
getVal方法得到：username = 李四 ,address = 昌平
synchronized锁重入
同一个线程得到了一个对象的锁之后，再次请求此对象时可以再次获得该对象的锁。同一个对象内的多个synchronized方法可以锁重入。
package com.aidata.concurrency; public class DemoThread05 { public synchronized void run1(){ System.out.println(Thread.currentThread().getName() + ">run1..."); // 调用同类中的synchronized方法不会引起死锁 run2(); } public synchronized void run2(){ System.out.println(Thread.currentThread().getName() + ">run2..."); } public static void main(String[] args) { final DemoThread05 demoThread05 = new DemoThread05(); Thread thread = new Thread(new Runnable() { public void run() { demoThread05.run1(); } }); thread.start(); } }
结果
Thread-0>run1...
Thread-0>run2...
父子锁可以重入
package com.aidata.concurrency; public class DemoThread06 { public static void main(String[] args) { Thread t0 = new Thread(new Runnable() { public void run() { Child sub = new Child(); sub.runChild(); } }); t0.start(); } } class Parent{ public int i = 10; public synchronized void runParent(){ try { i--; System.out.println("Parent>>>i=" + i); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } class Child extends Parent{ public synchronized void runChild(){ try{ while (i > 0){ i--; System.out.println("Child>>>i=" + i); Thread.sleep(100); // 调用父类的synchronized方法不会引起死锁 this.runParent(); } }catch (InterruptedException e){ e.printStackTrace(); } } }
结果
Child>>>i=9 Parent>>>i=8 Child>>>i=7 Parent>>>i=6 Child>>>i=5 Parent>>>i=4 Child>>>i=3 Parent>>>i=2 Child>>>i=1 Parent>>>i=0
抛出异常释放锁
一个线程在获得锁之后执行操作，发送错误抛出异常，则自动释放锁。
while死循环，我们想在第十次释放锁：
package com.aidata.concurrency; public class DemoThread07 { private int i = 0; public synchronized void run(){ while (true){ i++; System.out.println(Thread.currentThread().getName() + "-run>i=" +i); try { Thread.sleep(1000); }catch (InterruptedException e){ e.printStackTrace(); } if (i == 10){ throw new RuntimeException(); } } } public synchronized void get(){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "-get>i=" +i); } public static void main(String[] args) throws InterruptedException { final DemoThread07 demoThread07 = new DemoThread07(); new Thread(new Runnable() { public void run() { demoThread07.run(); } }, "t0").start(); // 保证t1线程先执行 Thread.sleep(1000); new Thread(new Runnable() { public void run() { demoThread07.get(); } }, "t1").start(); } }
结果
t0-run>i=1 t0-run>i=2 t0-run>i=3 t0-run>i=4 t0-run>i=5 t0-run>i=6 t0-run>i=7 t0-run>i=8 t0-run>i=9 t0-run>i=10 Exception in thread "t0" java.lang.RuntimeException at com.aidata.concurrency.DemoThread07.run(DemoThread07.java:18) at com.aidata.concurrency.DemoThread07$1.run(DemoThread07.java:36) at java.lang.Thread.run(Thread.java:748) t1-get>i=10
总结：
1.可以利用抛出异常，主动释放锁
2.程序异常时防止资源被死锁、无法释放
3.异常释放锁可能导致数据不一致
Synchronized代码块和锁失效问题
synchronized代码块
可以达到更细粒度的控制
- 当前对象锁
- 类锁
- 任意锁
package com.aidata.concurrency; public class DemoThread08 { public void run1(){ synchronized (this){ try { System.out.println(Thread.currentThread().getName() + ">当前对象锁..."); Thread.sleep(2000); }catch (InterruptedException e){ e.printStackTrace(); } } } public void run2(){ synchronized (DemoThread08.class){ try { System.out.println(Thread.currentThread().getName() + ">类锁..."); Thread.sleep(2000); }catch (InterruptedException e){ e.printStackTrace(); } } } private Object objectLock = new Object(); public void run3(){ synchronized (objectLock){ try { System.out.println(Thread.currentThread().getName() + ">任意锁..."); Thread.sleep(2000); }catch (InterruptedException e){ e.printStackTrace(); } } } // 测试方法 public static void test(final int type){ if (type == 1){ System.out.println("当前对象锁测试..."); }else if (type == 2){ System.out.println("类锁测试..."); }else { System.out.println("任意对象锁测试..."); } final DemoThread08 demo1 = new DemoThread08(); final DemoThread08 demo2 = new DemoThread08(); Thread t0 = new Thread(new Runnable() { public void run() { if (type == 1){ demo1.run1(); }else if (type == 2){ demo1.run2(); }else { demo1.run3(); } } }, "t0"); Thread t1 = new Thread(new Runnable() { public void run() { if (type == 1){ demo2.run1(); }else if (type == 2){ demo2.run2(); }else { demo2.run3(); } } }, "t1"); t0.start(); t1.start(); } public static void main(String[] args) { test(1); // test(2); // test(3); } }
同类型锁之间互斥，不同类型的锁之间互不干扰
package com.aidata.concurrency; public class DemoThread08 { public void run1(){ synchronized (this){ try { System.out.println(Thread.currentThread().getName() + ">当前对象锁..."); Thread.sleep(2000); }catch (InterruptedException e){ e.printStackTrace(); } } } public void run2(){ synchronized (DemoThread08.class){ try { System.out.println(Thread.currentThread().getName() + ">类锁..."); Thread.sleep(2000); }catch (InterruptedException e){ e.printStackTrace(); } } } private Object objectLock = new Object(); public void run3(){ synchronized (objectLock){ try { System.out.println(Thread.currentThread().getName() + ">任意锁..."); Thread.sleep(2000); }catch (InterruptedException e){ e.printStackTrace(); } } }public static void main(String[] args) { final DemoThread08 demo1 = new DemoThread08(); final DemoThread08 demo2 = new DemoThread08(); Thread t1 = new Thread(new Runnable() { public void run() { demo1.run2(); } }, "t1"); t1.start(); // 保证t1先运行 try { Thread.sleep(100); }catch (InterruptedException e){ e.printStackTrace(); } Thread t2 = new Thread(new Runnable() { public void run() { demo2.run1(); } }, "t2"); t2.start(); } }
没有等待，瞬间完成，也就是不同类型的锁之间互不干扰
t1>类锁...
t2>当前对象锁...
不要在线程内修改对象锁的引用
引用被改变会导致锁失效
package com.aidata.concurrency; public class DemoThread09 { private String lock = "lock handler"; private void method(){ synchronized (lock){ try { System.out.println("当前线程：" + Thread.currentThread().getName() + "开始"); // 锁的引用被改变，则其他线程可获得锁，导致并发问题 lock = "change lock handler"; Thread.sleep(2000); System.out.println("当前线程：" + Thread.currentThread().getName() + "结束"); }catch (InterruptedException e){ e.printStackTrace(); } } } public static void main(String[] args) { final DemoThread09 changeLock = new DemoThread09(); Thread t1 = new Thread(new Runnable() { public void run() { changeLock.method(); } }, "t1"); Thread t2 = new Thread(new Runnable() { public void run() { changeLock.method(); } }, "t2"); t1.start(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } // 由于锁的引用被改变，所有t2线程也进入到method方法内执行 t2.start(); } }
结果线程不安全：
当前线程：t1开始
当前线程：t2开始
当前线程：t1结束
当前线程：t2结束
线程A修改了对象锁的引用，则线程B实际得到了新的对象锁，而不是锁被释放了，不是同一个锁了，因此引发了线程安全问题
在线程中修改了锁对象的属性，而不修改引用则不会引起锁失效，不会产生线程安全问题
并发与死锁
指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在相关等待的进程称为死锁进程。
package com.aidata.concurrency; import org.omg.Messaging.SYNC_WITH_TRANSPORT; public class DemoThread10 { private Object lock1 = new Object(); private Object lock2 = new Object(); public void execute1(){ // 尝试获得lock1的锁 synchronized (lock1){ System.out.println("线程" + Thread.currentThread().getName() + " 获得lock1执行execute1开始"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } // 尝试或得lock2锁 synchronized (lock2){ System.out.println("线程" + Thread.currentThread().getName() + " 获得lock2执行execute1开始"); } } } public void execute2(){ synchronized (lock2){ System.out.println("线程" + Thread.currentThread().getName() + " 获得lock2执行execute2开始"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lock1){ System.out.println("线程" + Thread.currentThread().getName() + " 获得lock1执行execute2开始"); } } } public static void main(String[] args) { final DemoThread10 demo = new DemoThread10(); new Thread(new Runnable() { public void run() { demo.execute1(); } }, "t1").start(); new Thread(new Runnable() { public void run() { demo.execute2(); } }, "t2").start(); } }
死锁，结果
线程t1 获得lock1执行execute1开始
线程t2 获得lock2执行execute2开始
线程t1在等lock2锁，线程2在等lock1锁
线程之间通讯
每个线程都是独立运行的个体，线程通讯能让多个线程之间协同工作
package com.aidata.concurrency; import java.util.ArrayList; import java.util.List; // while方式 public class DemoThread11 { private volatile List<String> list = new ArrayList<String>(); private volatile boolean canGet = false; public void put(){ for (int i=0; i<10; i++) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } list.add("A"); System.out.println("线程" + Thread.currentThread().getName() + "添加第" + i + "个元素"); if (i==5){ // 循环到第i次则通知其他线程开始获取数据进行处理 canGet = true; System.out.println("线程" + Thread.currentThread().getName() + " 发出通知"); } } } public void get(){ while (true){ if (canGet){ for (String s: list){ System.out.println("线程" + Thread.currentThread().getName() + "获取元素：" + s); } break; } } } public static void main(String[] args) { final DemoThread11 demo = new DemoThread11(); new Thread(new Runnable() { public void run() { demo.put(); } }, "t1").start(); new Thread(new Runnable() { public void run() { demo.get(); } }, "t2").start(); } }
结果
线程t1添加第0个元素
线程t1添加第1个元素
线程t1添加第2个元素
线程t1添加第3个元素
线程t1添加第4个元素
线程t1添加第5个元素
线程t1 发出通知
线程t2获取元素：A
线程t2获取元素：A
线程t2获取元素：A
线程t2获取元素：A
线程t2获取元素：A
线程t2获取元素：A
线程t1添加第6个元素
线程t1添加第7个元素
线程t1添加第8个元素
线程t1添加第9个元素
Object类中的wait/notify方法可以实现线程间通讯
wait/notify必须与synchronized一通使用
wait释放锁，notify不释放锁
锁池和等待池
锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。
等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁后，进入到了该对象的等待池中
Reference：java中的锁池和等待池
然后再来说notify和notifyAll的区别
如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。
当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争
优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。
综上，所谓唤醒线程，另一种解释可以说是将线程由等待池移动到锁池，notifyAll调用后，会将全部线程由等待池移到锁池，然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在锁池等待锁被释放后再次参与竞争。而notify只会唤醒一个线程。
有了这些理论基础，后面的notify可能会导致死锁，而notifyAll则不会的例子也就好解释了
package com.aidata.concurrency; import java.util.ArrayList; import java.util.List; // wait/notify方式 public class DemoThread12 { private volatile List<String> list = new ArrayList<String>(); private Object lock = new Object(); public void put(){ synchronized (lock){ for (int i=0; i<10; i++) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } list.add("A"); System.out.println("线程" + Thread.currentThread().getName() + "添加第" + i + "个元素"); if (list.size()==5){ // 数据准备好了，发出唤醒通知，但是不释放锁 lock.notify(); System.out.println("线程" + Thread.currentThread().getName() + " 发出通知"); } } } } public void get(){ synchronized (lock){ try { System.out.println("线程" + Thread.currentThread().getName() + "业务处理，发现需要的数据没准备好，则发起等待"); System.out.println("线程" + Thread.currentThread().getName() + " wait"); // wait操作释放锁，否则其他线程无法进入put方法 lock.wait(); System.out.println("线程" + Thread.currentThread().getName() + "被唤醒"); for (String s: list){ System.out.println("线程" + Thread.currentThread().getName() + "获取元素：" + s); } }catch (InterruptedException e){ e.printStackTrace(); } } } public static void main(String[] args) { final DemoThread12 demo = new DemoThread12(); new Thread(new Runnable() { public void run() { demo.get(); } }, "t1").start(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } new Thread(new Runnable() { public void run() { demo.put(); } }, "t2").start(); } }
结果：
线程t1业务处理，发现需要的数据没准备好，则发起等待
线程t1 wait
线程t2添加第0个元素
线程t2添加第1个元素
线程t2添加第2个元素
线程t2添加第3个元素
线程t2添加第4个元素
线程t2 发出通知
线程t2添加第5个元素
线程t2添加第6个元素
线程t2添加第7个元素
线程t2添加第8个元素
线程t2添加第9个元素
线程t1被唤醒
线程t1获取元素：A
线程t1获取元素：A
线程t1获取元素：A
线程t1获取元素：A
线程t1获取元素：A
线程t1获取元素：A
线程t1获取元素：A
线程t1获取元素：A
线程t1获取元素：A
线程t1获取元素：A
上面的高亮可知，wait释放锁给t2，notify不释放锁，t2继续添加元素
notify只会通知一个wait中的线程，并把锁给他，不会产生锁竞争问题，但是该线程处理完毕后必须再次notify或notifyAll，完成类似链式操作。
notifyAll会通知所有wait中的线程，会产生锁竞争问题。
package com.aidata.concurrency; public class DemoThread13 { public synchronized void run1(){ System.out.println("进入run1方法..."); // this.notifyAll(); this.notify(); System.out.println("run1执行完毕，通知完毕..."); } public synchronized void run2(){ try { System.out.println("进入run2方法..."); this.wait(); System.out.println("run2执行完毕，通知完毕..."); this.notify(); System.out.println("run2发出通知..."); }catch (InterruptedException e){ e.printStackTrace(); } } public synchronized void run3(){ try { System.out.println("进入run3方法..."); this.wait(); System.out.println("run3执行完毕，通知完毕..."); this.notify(); System.out.println("run3发出通知..."); }catch (InterruptedException e){ e.printStackTrace(); } } public static void main(String[] args) throws InterruptedException { final DemoThread13 demo = new DemoThread13(); new Thread(new Runnable() { public void run() { demo.run2(); } }).start(); new Thread(new Runnable() { public void run() { demo.run3(); } }).start(); Thread.sleep(1000); new Thread(new Runnable() { public void run() { demo.run1(); } }).start(); } }
结果
进入run2方法...
进入run3方法...
进入run1方法...
run1执行完毕，通知完毕...
run2执行完毕，通知完毕...
run2发出通知...
run3执行完毕，通知完毕...
run3发出通知...
notify只能通知一个，必须链式的顺序通知，t2通知t3，t3通知t1
打开t1的notifyAll，关闭t2、t3的notify
package com.aidata.concurrency; public class DemoThread13 { public synchronized void run1(){ System.out.println("进入run1方法..."); this.notifyAll(); System.out.println("run1执行完毕，通知完毕..."); } public synchronized void run2(){ try { System.out.println("进入run2方法..."); this.wait(); System.out.println("run2执行完毕，通知完毕..."); }catch (InterruptedException e){ e.printStackTrace(); } } public synchronized void run3(){ try { System.out.println("进入run3方法..."); this.wait(); System.out.println("run3执行完毕，通知完毕..."); }catch (InterruptedException e){ e.printStackTrace(); } } public static void main(String[] args) throws InterruptedException { final DemoThread13 demo = new DemoThread13(); new Thread(new Runnable() { public void run() { demo.run2(); } }).start(); new Thread(new Runnable() { public void run() { demo.run3(); } }).start(); Thread.sleep(1000); new Thread(new Runnable() { public void run() { demo.run1(); } }).start(); } }
notifyAll可以通知所有线程，会有锁竞争
进入run2方法...
进入run3方法...
进入run1方法...
run1执行完毕，通知完毕...
run3执行完毕，通知完毕...
run2执行完毕，通知完毕...
Object中的wait
/** * Causes the current thread to wait until either another thread invokes the * {@link java.lang.Object#notify()} method or the * {@link java.lang.Object#notifyAll()} method for this object, or a * specified amount of time has elapsed. * <p> * The current thread must own this object's monitor. * <p> * This method causes the current thread (call it <var>T</var>) to * place itself in the wait set for this object and then to relinquish * any and all synchronization claims on this object. Thread <var>T</var> * becomes disabled for thread scheduling purposes and lies dormant * until one of four things happens: * <ul> * <li>Some other thread invokes the {@code notify} method for this * object and thread <var>T</var> happens to be arbitrarily chosen as * the thread to be awakened. * <li>Some other thread invokes the {@code notifyAll} method for this * object. * <li>Some other thread {@linkplain Thread#interrupt() interrupts} * thread <var>T</var>. * <li>The specified amount of real time has elapsed, more or less. If * {@code timeout} is zero, however, then real time is not taken into * consideration and the thread simply waits until notified. * </ul> * The thread <var>T</var> is then removed from the wait set for this * object and re-enabled for thread scheduling. It then competes in the * usual manner with other threads for the right to synchronize on the * object; once it has gained control of the object, all its * synchronization claims on the object are restored to the status quo * ante - that is, to the situation as of the time that the {@code wait} * method was invoked. Thread <var>T</var> then returns from the * invocation of the {@code wait} method. Thus, on return from the * {@code wait} method, the synchronization state of the object and of * thread {@code T} is exactly as it was when the {@code wait} method * was invoked. * <p> * A thread can also wake up without being notified, interrupted, or * timing out, a so-called <i>spurious wakeup</i>. While this will rarely * occur in practice, applications must guard against it by testing for * the condition that should have caused the thread to be awakened, and * continuing to wait if the condition is not satisfied. In other words, * waits should always occur in loops, like this one: * <pre> * synchronized (obj) { * while (<condition does not hold>) * obj.wait(timeout); * ... // Perform action appropriate to condition * } * </pre> * (For more information on this topic, see Section 3.2.3 in Doug Lea's * "Concurrent Programming in Java (Second Edition)" (Addison-Wesley, * 2000), or Item 50 in Joshua Bloch's "Effective Java Programming * Language Guide" (Addison-Wesley, 2001). * * <p>If the current thread is {@linkplain java.lang.Thread#interrupt() * interrupted} by any thread before or while it is waiting, then an * {@code InterruptedException} is thrown. This exception is not * thrown until the lock status of this object has been restored as * described above. * * <p> * Note that the {@code wait} method, as it places the current thread * into the wait set for this object, unlocks only this object; any * other objects on which the current thread may be synchronized remain * locked while the thread waits. * <p> * This method should only be called by a thread that is the owner * of this object's monitor. See the {@code notify} method for a * description of the ways in which a thread can become the owner of * a monitor. * * @param timeout the maximum time to wait in milliseconds. * @throws IllegalArgumentException if the value of timeout is * negative. * @throws IllegalMonitorStateException if the current thread is not * the owner of the object's monitor. * @throws InterruptedException if any thread interrupted the * current thread before or while the current thread * was waiting for a notification. The <i>interrupted * status</i> of the current thread is cleared when * this exception is thrown. * @see java.lang.Object#notify() * @see java.lang.Object#notifyAll() */ public final native void wait(long timeout) throws InterruptedException; /** * Causes the current thread to wait until another thread invokes the * {@link java.lang.Object#notify()} method or the * {@link java.lang.Object#notifyAll()} method for this object, or * some other thread interrupts the current thread, or a certain * amount of real time has elapsed. * <p> * This method is similar to the {@code wait} method of one * argument, but it allows finer control over the amount of time to * wait for a notification before giving up. The amount of real time, * measured in nanoseconds, is given by: * <blockquote> * <pre> * 1000000*timeout+nanos</pre></blockquote> * <p> * In all other respects, this method does the same thing as the * method {@link #wait(long)} of one argument. In particular, * {@code wait(0, 0)} means the same thing as {@code wait(0)}. * <p> * The current thread must own this object's monitor. The thread * releases ownership of this monitor and waits until either of the * following two conditions has occurred: * <ul> * <li>Another thread notifies threads waiting on this object's monitor * to wake up either through a call to the {@code notify} method * or the {@code notifyAll} method. * <li>The timeout period, specified by {@code timeout} * milliseconds plus {@code nanos} nanoseconds arguments, has * elapsed. * </ul> * <p> * The thread then waits until it can re-obtain ownership of the * monitor and resumes execution. * <p> * As in the one argument version, interrupts and spurious wakeups are * possible, and this method should always be used in a loop: * <pre> * synchronized (obj) { * while (<condition does not hold>) * obj.wait(timeout, nanos); * ... // Perform action appropriate to condition * } * </pre> * This method should only be called by a thread that is the owner * of this object's monitor. See the {@code notify} method for a * description of the ways in which a thread can become the owner of * a monitor. * * @param timeout the maximum time to wait in milliseconds. * @param nanos additional time, in nanoseconds range * 0-999999. * @throws IllegalArgumentException if the value of timeout is * negative or the value of nanos is * not in the range 0-999999. * @throws IllegalMonitorStateException if the current thread is not * the owner of this object's monitor. * @throws InterruptedException if any thread interrupted the * current thread before or while the current thread * was waiting for a notification. The <i>interrupted * status</i> of the current thread is cleared when * this exception is thrown. */ public final void wait(long timeout, int nanos) throws InterruptedException { if (timeout < 0) { throw new IllegalArgumentException("timeout value is negative"); } if (nanos < 0 || nanos > 999999) { throw new IllegalArgumentException( "nanosecond timeout value out of range"); } if (nanos > 0) { timeout++; } wait(timeout); } /** * Causes the current thread to wait until another thread invokes the * {@link java.lang.Object#notify()} method or the * {@link java.lang.Object#notifyAll()} method for this object. * In other words, this method behaves exactly as if it simply * performs the call {@code wait(0)}. * <p> * The current thread must own this object's monitor. The thread * releases ownership of this monitor and waits until another thread * notifies threads waiting on this object's monitor to wake up * either through a call to the {@code notify} method or the * {@code notifyAll} method. The thread then waits until it can * re-obtain ownership of the monitor and resumes execution. * <p> * As in the one argument version, interrupts and spurious wakeups are * possible, and this method should always be used in a loop: * <pre> * synchronized (obj) { * while (<condition does not hold>) * obj.wait(); * ... // Perform action appropriate to condition * } * </pre> * This method should only be called by a thread that is the owner * of this object's monitor. See the {@code notify} method for a * description of the ways in which a thread can become the owner of * a monitor. * * @throws IllegalMonitorStateException if the current thread is not * the owner of the object's monitor. * @throws InterruptedException if any thread interrupted the * current thread before or while the current thread * was waiting for a notification. The <i>interrupted * status</i> of the current thread is cleared when * this exception is thrown. * @see java.lang.Object#notify() * @see java.lang.Object#notifyAll() */ public final void wait() throws InterruptedException { wait(0); }
阻塞式线程安全队列
package com.aidata.concurrency; import java.util.ArrayList; import java.util.List; class MQueue { private List<String> list = new ArrayList<String>(); private int maxSize; private Object lock = new Object(); public MQueue(int maxSize){ this.maxSize = maxSize; System.out.println("线程" + Thread.currentThread().getName() + "已初始化长度为" + this.maxSize + "队列"); } public void put(String element){ synchronized (lock){ if (this.list.size() == this.maxSize){ try { System.out.println("线程" + Thread.currentThread().getName() + "当前队列已满put等待..."); lock.wait(); }catch (InterruptedException e){ e.printStackTrace(); } } this.list.add(element); System.out.println("线程"+Thread.currentThread().getName()+"向队列中加入元素："+element); lock.notify(); // 通知可以取数据 } } public String take(){ synchronized (lock){ if (this.list.size()==0){ try { System.out.println("线程"+Thread.currentThread().getName()+"队列为空take等待..."); // 空，需要wait lock.wait(); }catch (InterruptedException e){ e.printStackTrace(); } } String result = list.get(0); list.remove(0); System.out.println("线程"+Thread.currentThread().getName()+"获取数据："+result); lock.notify(); // 通知可以加入线程 return result; } } } public class ThreadDemo13 { public static void main(String[] args) { final MQueue q = new MQueue(5); new Thread(new Runnable() { public void run() { q.put("1"); q.put("2"); q.put("3"); q.put("4"); q.put("5"); q.put("6"); } }, "t1").start(); new Thread(new Runnable() { public void run() { q.put("11"); q.put("21"); q.put("31"); q.put("41"); q.put("51"); q.put("61"); } }, "t2").start(); new Thread(new Runnable() { public void run() { q.take(); q.take(); q.take(); q.take(); q.take(); } }, "t3").start(); new Thread(new Runnable() { public void run() { q.take(); q.take(); q.take(); q.take(); q.take(); } }, "t4").start(); } }
结果：
线程main已初始化长度为5队列 线程t1向队列中加入元素：1 线程t1向队列中加入元素：2 线程t1向队列中加入元素：3 线程t1向队列中加入元素：4 线程t1向队列中加入元素：5 线程t1当前队列已满put等待... 线程t2当前队列已满put等待... 线程t3获取数据：1 线程t3获取数据：2 线程t3获取数据：3 线程t3获取数据：4 线程t3获取数据：5 线程t1向队列中加入元素：6 线程t2向队列中加入元素：11 线程t2向队列中加入元素：21 线程t2向队列中加入元素：31 线程t2向队列中加入元素：41 线程t2当前队列已满put等待... 线程t4获取数据：6 线程t4获取数据：11 线程t4获取数据：21 线程t4获取数据：31 线程t4获取数据：41 线程t2向队列中加入元素：51 线程t2向队列中加入元素：61
守护线程和用户线程
线程分类：daemon线程和user线程
main函数所在线程就是一个用户线程
只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。
User和Daemon两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。 因为没有了被守护者，Daemon也就没有工作可做了，也就没有继续运行程序的必要了。
- 最后一个user线程结束时，JVM会正常退出，不管是否有守护线程正在运行。反过来说，只要有一个用户线程还没结束，JVM进程就不会结束。
- 父线程结束后，子线程还可以继续存活，子线程的生命周期不受父线程影响。
package com.aidata.concurrency; public class DaemonAndUserThreadDemo { public static void main(String[] args) { Thread thread = new Thread(new Runnable() { public void run() { while (true){} } }); thread.start(); // 输出线程是否为守护线程 System.out.println(thread.getName() + " is daemon" + thread.isDaemon()); System.out.println(Thread.currentThread().getName() + " is daemon? " + Thread.currentThread().isDaemon()); System.out.println("main is over"); } }
即使父线程结束，不会运行结束，子线程继续存活：
设为守护线程
package com.aidata.concurrency; public class DaemonAndUserThreadDemo { public static void main(String[] args) { Thread thread = new Thread(new Runnable() { public void run() { while (true){} } }); thread.setDaemon(true); thread.start(); // 输出线程是否为守护线程 System.out.println(thread.getName() + " is daemon" + thread.isDaemon()); System.out.println(Thread.currentThread().getName() + " is daemon? " + Thread.currentThread().isDaemon()); System.out.println("main is over"); } }
结果：
Thread-0 is daemontrue main is daemon? false main is over
线程上下文切换
当前线程使用完时间片后会进入就绪状态，让出CPU执行权给其他线程，此时就是从当前线程的上下文切换到了其他线程。
当发生上下文切换的时候需要保存执行现场，等待下次执行时进行恢复。所以，频繁大量上下文切换会造成一定资源开销。