java 多个线程按顺序交替执行
使用Thread.join()
join主要是让父线程等待子线程结束之后父线程才能继续运行
public static void main(String[] args) throws InterruptedException {
MyThread thread1 = new MyThread("线程1");
thread1.start();
thread1.join();
MyThread thread2 = new MyThread("线程2");
thread2.start();
thread2.join();
MyThread thread3 = new MyThread("线程2");
thread3.start();
thread3.join();
}
static class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
super.run();
System.out.println(Thread.currentThread().getName() + "执行了");
}
}
使用FutureTask
public static void main(String[] args) throws InterruptedException, Exception {
FutureTask<String> task1 = new FutureTask<>(new MyClass());
Thread t1 = new Thread(task1, "线程1");
t1.start();
System.out.println("线程1返回结果" + task1.get());
FutureTask<String> task2 = new FutureTask<>(new MyClass());
Thread t2 = new Thread(task2, "线程2");
t2.start();
System.out.println("线程2返回结果" + task2.get());
FutureTask<String> task3 = new FutureTask<>(new MyClass());
Thread t3 = new Thread(task3, "线程3");
t3.start();
System.out.println("线程3返回结果" + task3.get());
}
static class MyClass implements Callable<String> {
@Override
public String call() throws Exception {
return Thread.currentThread().getName();
}
}
使用CountDownLatch
CountDownLatch使用一个计数器，调用await()方法计数器+1,调用countDown()方法计数器-1，当计数器为0时，使用await()方法的线程可以继续运行。
private static CountDownLatch c1 = new CountDownLatch(1);
private static CountDownLatch c2 = new CountDownLatch(1);
public static void main(String[] args) throws InterruptedException, Exception {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(500);
System.out.println("线程1执行");
c1.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "线程1");
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
c1.await();
System.out.println("线程2执行");
c2.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "线程2");
t2.start();
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
try {
c2.await();
System.out.println("线程3执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "线程3");
t3.start();
}
使用wait、notify
private static final Object lock1 = new Object();
private static final Object lock2 = new Object();
public static void main(String[] args) throws InterruptedException, Exception {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock1) {
try {
lock1.wait();
Thread.sleep(500);
System.out.println("线程1执行");
lock1.notify();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "线程1");
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock1) {
try {
lock1.notify();
lock1.wait();
System.out.println("线程2执行");
synchronized (lock2) {
lock2.notify();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "线程2");
t2.start();
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock2) {
try {
lock2.wait();
System.out.println("线程3执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "线程3");
t3.start();
}
使用ReentrantLock()
private static Lock lock = new ReentrantLock();
private static Condition condition1 = lock.newCondition();
private static Condition condition2 = lock.newCondition();
public static void main(String[] args) throws InterruptedException, Exception {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
lock.lock();
condition1.await();
Thread.sleep(500);
System.out.println("线程1执行了");
condition1.signal();
lock.unlock();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "线程1");
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
lock.lock();
condition1.signal();
condition1.await();
System.out.println("线程2执行");
condition2.signal();
lock.unlock();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "线程2");
t2.start();
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
try {
lock.lock();
condition2.await();
System.out.println("线程3执行");
lock.unlock();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "线程3");
t3.start();
}
使用线程池的单例池
private static ExecutorService executorService = Executors.newSingleThreadExecutor();
public static void main(String[] args) throws InterruptedException, Exception {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(500);
System.out.println("线程1执行了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "线程1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(200);
System.out.println("线程2执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "线程2");
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(10);
System.out.println("线程3执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "线程3");
executorService.submit(t1);
executorService.submit(t2);
executorService.submit(t3);
}
多线程的线程池
private static ExecutorService executorService = Executors.newFixedThreadPool(3);
public static void main(String[] args) throws InterruptedException, ExecutionException {
long start = System.currentTimeMillis();
ArrayList<Future<String>> futureList = new ArrayList<Future<String>>();
ArrayList<String> names = new ArrayList<String>();
for (int i = 0; i < 3; i++) {
futureList.add(executorService.submit(new MyCall(i + "")));
}
for (int i = 0; i < 3; i++) {
Future<String> future = futureList.get(i);
String value = future.get();
System.out.println("线程"+value+"执行了");
}
long spendTime = System.currentTimeMillis() - start;
System.out.println("花费时间---"+spendTime);
}
static class MyCall implements Callable<String> {
private String name;
public MyCall(String name) {
this.name = name;
}
@Override
public String call() throws Exception {
switch (name){
case "0":
Thread.sleep(3000);
break;
case "1":
Thread.sleep(2000);
break;
case "2":
Thread.sleep(1000);
break;
}
return name;
}
}
通过wait和notify让两个线程交替打印1-100
public static void main(String[] args) throws InterruptedException {
MyThread thread1 = new MyThread("线程1");
MyThread thread2 = new MyThread("线程2");
thread1.start();
thread2.start();
}
static class MyThread extends Thread {
static int num;
static Object object = new Object();
public MyThread(String name) {
super(name);
}
@Override
public void run() {
while (true) {
synchronized (object) {
object.notify();
if (num < 100) {
num++;
System.out.println(Thread.currentThread().getName() + ": " + num);
} else {
break;
}
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
使用Reentranlock实现交替打印
public static void main(String[] args) throws InterruptedException {
MyThread thread1 = new MyThread("线程1", 0);
MyThread thread2 = new MyThread("线程2", 1);
thread1.start();
thread2.start();
}
private static volatile int flag = 0;
static class MyThread extends Thread {
private static int number = 0;
private int flag = 0;
private static ReentrantLock lock = new ReentrantLock();
private static Condition condition = lock.newCondition();
public MyThread(String name, int flag) {
super(name);
this.flag = flag;
}
@Override
public void run() {
while (number < 100) {
lock.lock();
if (number >= 100) break;
if (number % 2 == this.flag) {
number++;
System.out.println(currentThread().getName() + ":" + number);
} else {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
condition.signal();
lock.unlock();
}
}
}
使用volatile关键字实现不加锁交替打印
//两个线程，一个打印奇数，一个打印偶数
public class OneToHundred{
static volatile int flag = 0;
public static void main(String[] args){
new Thread(new Task1(),"A").start();
new Thread(new Task2(),"B").start();
}
}
class Task1 implements Runnable{
@Override
public void run(){
int i = -2;
while(i<=99){
if(OneToHundred.flag == 0){
i+=2;
System.out.println("a:" + i);
OneToHundred.flag = 1;
}
}
}
}
class Task2 implements Runnable{
@Override
public void run(){
int i = -1;
while(i<=98){
if(OneToHundred.flag == 1){
i+=2;
System.out.println("b:" + i);
OneToHundred.flag = 0;
}
}
}
}