四、线程控制API
1、Lock：同synchronize，用于实现同步，保证多线程有序执行
ReentrantLock()：创建可重入锁对象
lock()：获取锁对象，锁对象属于当前线程，如果被其他线程占用，则进入阻塞状态
unlock()：释放锁对象，如果在线程执行结束前未释放，那么锁对象将被TERMINATED线程一直占用，其他线程将永远无法获得锁，从而导致死锁。务必在finally块中执行，防止程序异常终止。
示例：保证静态共享的num，分别被5个加线程和减线程调用后，结果为0
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockThread extends Thread{
private static Lock lock = new ReentrantLock();//establish static lock for all
private static int num = 0;
private String name;
public LockThread(String name) {
this.name = name;
}
@Override
public void run(){
lock.lock();//belong to current thread not the thread object
lock.lock();//lock count +1, just test for fun
try{
if(name.equals("add")){
for(int i=0;i<10;i++){
num++;
}
}else if(name.equals("minus")){
for(int i=0;i<10;i++){
num--;
}
}
System.out.println(name+":"+num);//final result must be 0
}finally{
this.myUnlock();//must in finally,you cant't be sure you program will be abnormal
this.myUnlock();//two lock ,two unlock
}
}
public void myUnlock(){
lock.unlock();//if thread terminated,you cant't do this operation
}
public static void main(String[] args) {
for(int i=0;i<10;i++){
if(i%2==0){
new LockThread("add").start();//add 5 times
}else{
new LockThread("minus").start();//minus 5 times
}
}
}
}add:10
add:20
add:30
minus:20
minus:10
minus:0
minus:-10
add:0
minus:-10
add:0ReentrantReadWriteLock
readLock可以与readLock并发执行，不发生阻塞，和writeLock相互排斥
示例：同时模拟synchronized和ReentrantReadWriteLock实现同步，并对比执行效率
扫描二维码关注公众号，回复：
2977622 查看本文章
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
public class ReadWriteLockThread extends Thread{
private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private static ReadLock readLock = lock.readLock();
private static WriteLock writeLock = lock.writeLock();
private static int num;
private static int num2;
private String name;
private static long endtime;
private static long endtime2;
public static int getNum() {
readLock.lock();//加读锁
try{
return num;
}finally{
readLock.unlock();
}
}
public static void addNum() {
writeLock.lock();//加写锁
try{
num++;
}finally{
writeLock.unlock();
}
}
public synchronized int getNum2() {
return num2;
}
public synchronized static void addNum2() {
num2++;
}
@Override
public void run(){
if(name.equals("readwrite")){
for(int i=0;i<1000;i++){
addNum();
getNum();
}
endtime = System.currentTimeMillis();
}else{
for(int i=0;i<1000;i++){
addNum2();
getNum2();
}
endtime2 = System.currentTimeMillis();
}
}
public ReadWriteLockThread(String name) {
this.name = name;
}
public static void main(String[] args) {
long starttime = System.currentTimeMillis();
for(int i=0;i<10;i++){
new ReadWriteLockThread("readwrite").start();
}
sleep(2000);
System.out.println("num="+num);//检验是否达到同步效果
System.out.println(endtime-starttime);//ReadWriteLock方式执行时间
starttime = System.currentTimeMillis();
for(int i=0;i<10;i++){
new ReadWriteLockThread("sync").start();
}
sleep(2000);
System.out.println("num2="+num2);//检验是否达到同步效果
System.out.println(endtime2-starttime);//synchronized方式执行时间
}
public static void sleep(long time){
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}执行结果：
num=10000
75
num2=10000
9
2、Condition：同wait和notify机制，用于实现按条件执行多线程
newCondition()：返回一个与锁相关的条件对象
await()：将线程放到条件的等待集中，此时释放lock占用，进入等待状态
signal()：随机选择一个线程，解除等待状态（可能进入Runnable也可能Blocked），容易死锁
signalAll()：解除条件等待集中所有线程的等待状态（可能进入Runnable也可能Blocked，因为还需要看是否能够获得lock）
注：以上三个方法，必须是lock锁的持有者才能调用
示例：保证静态共享的num，分别被5个加线程和减线程调用后，结果为0，并且调用过程中num不能小于0
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionThread extends Thread{
private static Lock lock = new ReentrantLock();
private static Condition condition = lock.newCondition();
private static int num = 0;//保证num不小于0
private String name;
public ConditionThread(String name) {
this.name = name;
}
@Override
public void run(){
lock.lock();
try {
if(name.equals("add")){
for(int i=0;i<10;i++){
num++;
}
condition.signalAll();//当num增加后，唤醒等待线程，唤醒的线程依然得等待lock
}else if(name.equals("minus")){
for(int i=0;i<10;i++){
while(num==0){//当num为零，且操作为minus时，线程等待并放弃锁
condition.await();
}
num--;
}
}
System.out.println(name+":"+num);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
public static void main(String[] args) {
for(int i=0;i<10;i++){
if(i%2!=0){
new ConditionThread("add").start();
}else{
new ConditionThread("minus").start();//先start，但await放弃lock
}
}
}
}
add:10
add:20
minus:10
add:20
minus:10
minus:0
add:10
minus:0
add:10
minus:0synchronized：同步关键字，可修饰方法或者代码块。占用者：对象锁或类锁
注：static 和非static 分别属于类锁和对象锁，互不干扰，当类锁被占用，此时由对象去调用static方法也将被阻塞，同时注意，static方法是无法影响对象本身私有属性。
wait：释放对象锁，进入等待状态
notify：随机选择一个线程，解除等待状态（可能进入Runnable也可能Blocked），容易死锁
notifyAll：解除条件等待集中所有线程的等待状态（可能进入Runnable也可能Blocked，因为还需要看是否能够获得对象锁）
注：以上三个方法（属于Object），必须是对象锁的持有者才能调用
示例：完成主线程和自定义线程之间的来回跳转，以及跳转过程的线程状态变化
public class WaitingThread extends Thread{
private static byte[] lock = new byte[0];//创建最简易的lock
public WaitingThread(String name) {
super(name);
}
@Override
public void run(){
try {
synchronized (lock) {
System.out.println(this.getState());//wait前,RUNNABLE状态
System.out.println("WaitingThread give out the lock");
lock.wait();
System.out.println("WaitingThread get the lock");
System.out.println(this.getState());//获得lock，重回RUNNABLE状态
lock.notifyAll();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
WaitingThread w = new WaitingThread("WaitingThread");
w.start();
try {
Thread.sleep(1000);//给WaitingThread执行wait的时间
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock) {
System.out.println("main thread get the lock!");
System.out.println(w.getState());//唤醒前,WAITING状态
lock.notifyAll();//唤醒WaitingThread
System.out.println(w.getState());//唤醒后,BLOCKED状态
try {
System.out.println("main give out the lock");
lock.wait();//让出锁给WaitingThread
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("main thread get the lock again!");
}
}
}RUNNABLE
WaitingThread give out the lock
main thread get the lock!
WAITING
BLOCKED
main give out the lock
WaitingThread get the lock
RUNNABLE
main thread get the lock again!4、volatile和atomic
volatile这个值的作用就是告诉JVM：对于这个成员变量不能保存它的副本，要直接与共享成员变量交互，也就保证在取值那一刻值是最新的。但是它不确保原子性（如果操作包含volatile修饰域本身）！
java.util.concurrent.atomic包中有许多用于原子操作的基础类型
示例：一并展示volatile和atomic在多线程下的执行情况
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicThread extends Thread{
private static volatile int num =0;
private static AtomicInteger atomicNum =new AtomicInteger(0);
@Override
public void run(){
add();
atomicAdd();
}
public void add(){
for(int i =0;i<10000;i++){
num=num+1;//执行过程中num值被其他线程修改
}
System.out.println("add: "+num);
}
public void atomicAdd(){
for(int i =0;i<10000;i++){
atomicNum.incrementAndGet();//等价i++,但AtomicInteger具备原子性
}
System.out.println("atomicAdd: "+atomicNum.get());
}
public static void main(String[] args) {
for(int i=0;i<20;i++){
new AtomicThread().start();
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("num最终结果："+num);
System.out.println("atomicNum最终结果："+atomicNum.get());
}
}num最终结果：155704
atomicNum最终结果：200000join() 方法主要是让调用该方法的thread完成run方法里面的任务后，再执行原线程join()方法后面的代码。
示例：mainthread线程最后一轮时，jointhread中途插入执行
public class JoinThread extends Thread{
private Thread joinThread;
public JoinThread(Thread t) {
joinThread = t;
}
@Override
public void run(){
for(int i=0;i<3;i++){
System.out.println(i);
if(i==2){
try {
joinThread.join();//joinThread执行完成后再回来执行后面代码
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("--over--");
}
}
public static void main(String[] args) {
Thread joinThread = new Thread(){
@Override
public void run(){
try {
Thread.sleep(1000);//让mainThread先执行
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("join!!!!");
System.out.println("over!!!!");
}
};
JoinThread mainThread = new JoinThread(joinThread);
joinThread.start();
mainThread.start();
}
}0
--over--
1
--over--
2
join!!!!
over!!!!
--over--6、interrupt(),interrupted()和isInterrupted()
interrupt():向线程发出中断请求，线程不会立即中断，只是将中断状态变为true。如果遇到sleep阻塞，那么抛出异常，并且中断状态重新变为false。
static interrupted():测试线程是否被中断，副作用：当前中断状态变为false。
isInterrupted():测试线程是否被中断，中断状态不改变
示例：展示中断方法的效果
public class InterruptThread extends Thread{
@Override
public void run(){
while(!this.isInterrupted()){
for(int i = 1;i<=5;i++){
System.out.println(i);
if(i==2){
System.out.println("执行interrupt()");
this.interrupt();//此时线程不会停下
}
}
System.out.println("当前中断状态："+this.isInterrupted());//中断状态不变
System.out.println("当前中断状态："+Thread.interrupted());//中断状态将改变成为false
if(!this.isInterrupted()){//如果线程中断状态不为true
this.interrupt();//再次中断程序
}
/*try {
Thread.sleep(5000);
} catch (InterruptedException e) {//中断状态将改变成为false
e.printStackTrace();
this.interrupt();
}*/
}
}
public static void main(String[] args) {
new InterruptThread().start();
}
}1
2
执行interrupt()
3
4
5
当前中断状态：true
当前中断状态：true7、stop,suspend和resume
这三个方法被弃用了。为啥呢？
stop：终止所有未结束的方法，将导致对象被破坏，比如钱从一个账户到另一个，中途stop，那么钱去哪了？O(∩_∩)O~
suspend：用于挂起线程，需要其他线程调用resume来回复，容易导致死锁。比如，a线程挂起，并持有b线程需要的锁，而b线程要执行resume将a回复，可惜锁又被a占用着，那么程序死锁。
示例：自定义挂起，回复线程
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ResumeThread extends Thread{
private Lock suspendLock = new ReentrantLock();
private Condition suspendCondition = suspendLock.newCondition();
private boolean suspend = false;//挂起标识
private void mySuspend(){
suspend = true;
}
private void myResume(){
suspend = false;
suspendLock.lock();//锁定
try{
suspendCondition.signalAll();//唤醒线程
}finally{
suspendLock.unlock();
}
}
@Override
public void run(){
while(true){
System.out.println("------ResumeThread------");
if(suspend){
suspendLock.lock();
try{
suspendCondition.await();//释放锁，进入等待状态
}catch (Exception e) {
e.printStackTrace();
}finally{
suspendLock.unlock();
}
}
sleep(1);
}
}
public static void main(String[] args) {
ResumeThread resumeT = new ResumeThread();
resumeT.start();
sleep(10);
System.out.println("-------suspend------");
resumeT.mySuspend();//挂起
System.out.println("-------resume------");
resumeT.myResume();//恢复
sleep(10);
System.out.println("-------suspend------");
resumeT.mySuspend();//再次挂起
System.exit(0);//结束程序
}
public static void sleep(long time){
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}------ResumeThread------
------ResumeThread------
------ResumeThread------
...
-------suspend------
-------resume------
------ResumeThread------
------ResumeThread------
------ResumeThread------
...
-------suspend------
------ResumeThread------