Java交替打印顺序1~100，5种线程间通讯技巧你得掌握
本人第一篇CSDN博客，哈哈哈，笔者来自于世界500强企业，先后在诺基亚，通用等大企业做过N多java后端项目核心开发，也积累了大量的开发经验，扯远了，关注文章标题，其实，这种面试题就是考察的Java多线程间通讯技术，其实在Java中，能够完成线程间的技术很多，本文列举5中方法，其他的方法请自行探索。
1.基于volatile变量规则
在java中，volatile可以保证变量的可见性和禁止指令重排（基于内存屏障），理解了这一点也就不难实现了。看代码：
/**
* 基于Volatile变量
*/
public class Test5 {
static volatile boolean FLAG = false;
static volatile int num = 1;
public static void main(String[] args) {
new Thread(() -> {
while (true) {
if (num < 101 && !FLAG) {
System.out.printf("线程Id:%s,打印的数字:%s \n", Thread.currentThread().getId(), num++);
FLAG = true;
}
}
}).start();
new Thread(() -> {
while (true) {
if (num < 101 && FLAG) {
System.out.printf("线程Id:%s,打印的数字:%s \n", Thread.currentThread().getId(), num++);
FLAG = false;
}
}
}).start();
}
}结果：
线程Id:9,打印的数字:1
线程Id:10,打印的数字:2
线程Id:9,打印的数字:3
线程Id:10,打印的数字:4.....
2.基于同步锁
也就是基于sychoronized同步块实现，同步锁基于语义为管程锁隐式实现的，重要两个命令monitor enter，monitor exit，
一旦方法或者代码块有同步锁标识，即当前线程自动进入monitor的entry_list等待获取锁，一旦获取到锁，则会进入临界区继续运行，假如此时调用了持有当前锁对象的wait()方法，当前线程会主动释放锁，并让出CPU资源，并进入monitor的wait_set等待唤醒。
/**
* 基于同步锁，即obj的wait()和notify方法
*/
public class Test {
static volatile int num = 1;
static Object obj = new Object();
public static void main(String[] args) {
new Thread(() -> {
while (num < 101) {
synchronized (obj) {
try {
obj.wait();
System.out.printf("线程Id:%s,打印的数字:%s \n", Thread.currentThread().getId(), num++);
obj.notify();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
new Thread(() -> {
while (num < 101) {
synchronized (obj) {
try {
System.out.printf("线程Id:%s,打印的数字:%s \n", Thread.currentThread().getId(), num++);
obj.notify();
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
}
3.基于重入锁
/**
* 基于重入锁
*/
public class Test2 {
static ReentrantLock reentrantLock = new ReentrantLock();
static Condition thread1Condition = reentrantLock.newCondition();
static Condition thread2Condition = reentrantLock.newCondition();
static volatile int num = 1;
public static void main(String[] args) {
new Thread(() -> {
while (num < 100) {
reentrantLock.lock();
try {
thread1Condition.await();
System.out.printf("线程Id:%s,打印的数字:%s \n", Thread.currentThread().getId(), num++);
thread2Condition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (reentrantLock.isHeldByCurrentThread()) {
reentrantLock.unlock();
}
}
}
}).start();
new Thread(() -> {
while (num < 100) {
reentrantLock.lock();
try {
System.out.printf("线程Id:%s,打印的数字:%s \n", Thread.currentThread().getId(), num++);
thread1Condition.signal();
thread2Condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (reentrantLock.isHeldByCurrentThread()) {
reentrantLock.unlock();
}
}
}
}).start();
}
}
4.基于信号量
/**
* 基于信号量
*/
public class Test3 {
static Semaphore thread1=new Semaphore(1);
static Semaphore thread2=new Semaphore(0);
static volatile int num=1;
public static void main(String[] args) {
new Thread(()->{
while (num<100){
try {
thread2.acquire();
System.out.printf("线程Id:%s,打印的数字:%s \n", Thread.currentThread().getId(), num++);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
thread1.release();
}
}
}).start();
new Thread(()->{
while (num<100){
try {
thread1.acquire();
System.out.printf("线程Id:%s,打印的数字:%s \n", Thread.currentThread().getId(), num++);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
thread2.release();
}
}
}).start();
}
}
5.基于LockSupport
/**
* 基于LockSupport
*/
public class Test4 {
private static volatile int num = 1;
public static void main(String[] args) {
Thread main=Thread.currentThread();
Thread thread1 = new Thread(() -> {
while (num < 101) {
LockSupport.park();
System.out.printf("线程Id:%s,打印的数字:%s \n", Thread.currentThread().getId(), num++);
LockSupport.unpark(main);
}
});
thread1.start();
while (num<101){
System.out.printf("线程Id:%s,打印的数字:%s \n", Thread.currentThread().getId(), num++);
LockSupport.unpark(thread1);
LockSupport.park();
}
}
}6.简单sleep()方法
之所以不太想提这种方法，主要是觉得这有点背离面试官的初衷，再一点我们在正常的生产环境是不能这样写的，哈哈哈，否则要被拉出去批斗，既然作为博客，我觉得应该集思广益，但万万不可用于生产环境的业务代码，自己玩玩可以。
/**
* 简单sleep
*/
public class Test6 {
static volatile int num=1;
public static void main(String[] args) {
new Thread(()->{
while (num<101){
try {
System.out.printf("线程Id:%s,打印的数字:%s \n", Thread.currentThread().getId(), num++);
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(()->{
while (num<101){
try {
System.out.printf("线程Id:%s,打印的数字:%s \n", Thread.currentThread().getId(), num++);
Thread.sleep(201);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
好啦，废话不多说，能让你们有所收获就好。