android 多线程并发处理,Android多线程-并发实例记录

多线程基本概念

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线程都开始