多线程基本概念
java多线程状态图.jpg
Java线程五种基本状态:
1)新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t = new MyThread();
2)就绪状态(Runnable):当调用线程对象的start()方法(t.start();),线程即进入就绪状态。处于就绪状态的线程,只是说明此线程已经做好了准备,随时等待CPU调度执行,并不是说执行了t.start()此线程立即就会执行;
3)运行状态(Running):当CPU开始调度处于就绪状态的线程时,此时线程才得以真正执行,即进入到运行状态。注:就 绪状态是进入到运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中;
4)阻塞状态(Blocked):处于运行状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才 有机会再次被CPU调用以进入到运行状态。
根据阻塞产生的原因不同,阻塞状态又可以分为三种:
1.等待阻塞:运行状态中的线程执行wait()方法,使本线程进入到等待阻塞状态;
2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态;
3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
5)死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
多线程竞争问题示例
/** 通过添加wait notify关键字去主动唤醒生产者或消费者线程的执行
* 当前代码不使用wait notify也可以,只不过使用wait、notify可以主动释放锁资源,以及主动获取锁资源
* 产品:No1585488600530
* 产品已消费
* 产品:No1585488600631
* 产品已消费
* 产品:No1585488600731
* 产品已消费
* 产品:No1585488600832
* 产品已消费
* 产品:No1585488600933
* 产品已消费
* **/
@Test
public void testWaitNotify(){
Object object = new Object();
Producer producer = new Producer(object);
Consumer consumer = new Consumer(object);
producer.start();
consumer.start();
//法1 让主线程等待
// try {
// Thread.sleep(3000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
//法2 主线程调用cosumer.join,直到consumer线程完成再忘下执行,防止结果未执行完main函数退出
try {
consumer.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static class Product{
public static String value;
}
public class Producer extends Thread{
Object object;
int n = 0;
public Producer(Object object){
this.object = object;
}
@Override
public void run() {
super.run();
while (true && n<=4){
synchronized (object){
if (Product.value != null){
try {
object.wait();//产品还未消费 进入等待状态
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Product.value = "No"+ System.currentTimeMillis();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("产品:" + Product.value);
n++;
object.notify();//产品已生产 唤醒消费者线程
}
}
}
}
public class Consumer extends Thread{
Object object;
int n = 0;
public Consumer(Object object){
this.object = object;
}
@Override
public void run() {
super.run();
while (true && n<=4){
synchronized (object){
if (Product.value == null){
try {
object.wait();//产品为空 进入等待状态
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Product.value = null;
System.out.println("产品已消费");
object.notify();//产品已经消费 唤醒生产者线程生产
}
}
}
}
join
join()方法的作用,是等待这个线程结束。也就是说,join()方法阻塞调用此方法的线程(calling thread)进入 TIMED_WAITING 状态,直到线程t完成,此线程再继续;
/**
* join()让指定的线程先执行完再执行其他线程,而且会阻塞主线程(调用join方法的线程)
* t.join()方法只会使主线程进入等待并等待t线程执行完毕后才会被唤醒。并不影响同一时刻处在运行状态的其他线程。
*
* 进入子线程1
* 线程一:1
* 线程一:1
* 线程一:1
* 进入子线程2
* 线程二:1
* 线程二:1
* 线程二:1
* 主线程执行完毕
* **/
@Test
public void testThreadJoin(){
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("进入子线程1");
try {
for (int i = 0; i < 3; i++) {
System.out.println("线程一:" + 1);
Thread.sleep(200);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
try {
t1.join();//join 该线程优先执行 其他线程进入等待
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("进入子线程2");
try {
for (int i = 0; i < 3; i++) {
System.out.println("线程二:" + 1);
Thread.sleep(200);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t2.start();
try {
t2.join(); //单元测试代码,类似于main函数,t2不join的话,循环还没执行完,main函数就退出了
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("主线程执行完毕");
}
/**
* t.join()方法只会使主线程(调用join方法的想爱你成)进入等待池并等待t线程执行完毕后才会被唤醒。并不影响同一时刻处在运行状态的其他线程。
* t.join()方法阻塞调用此方法的线程(calling thread)进入 TIMED_WAITING 状态,直到线程t完成,此线程再继续
* 进入子线程1
* 线程一:1
* 进入子线程2
* 线程二:1
* 线程一:1
* 线程二:1
* 线程一:1
* 线程二:1
* 主线程执行完毕
* **/
@Test
public void testThreadJoin2(){
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("进入子线程1");
try {
for (int i = 0; i < 3; i++) {
System.out.println("线程一:" + 1);
Thread.sleep(200);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("进入子线程2");
try {
for (int i = 0; i < 3; i++) {
System.out.println("线程二:" + 1);
Thread.sleep(200);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t2.start();
//t1、t2线程都开始