题目
跟标题一样,就是依次打印10次ABC,不过是由三个线程来完成的,这个时候就要考虑到那些线程之间的竞争问题!
思路1
可以lock锁,三个线程共同竞争一把锁,竞争到了而且是属于自己该打印的就去打印!
代码1
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Main{
private static Lock lock = new ReentrantLock();
private static int state = 0;
public static void main(String[] args)
{
new Thread(new ThreadA()).start();
new Thread(new ThreadB()).start();
new Thread(new ThreadC()).start();
}
static class ThreadA implements Runnable
{
@Override
public void run() {
for (int i=0;i<10;)
{
try
{
lock.lock();//上锁
while (state%3==0)
{
System.out.println("A");
++state;
++i;
}
}
finally
{
lock.unlock(); // 解锁
}
}
}
}
static class ThreadB implements Runnable
{
@Override
public void run() {
for (int i=0;i<10;)
{
try
{
lock.lock();
while (state%3==1)
{
System.out.println("B");
++state;
++i;
}
}
finally {
lock.unlock();
}
}
}
}
static class ThreadC implements Runnable
{
@Override
public void run()
{
for (int i=0;i<10;)
{
try
{
lock.lock();
while (state%3==2)
{
System.out.println("C");
++state;
++i;
}
}
finally
{
lock.unlock();
}
}
}
}
}
结果1
这样子是可以的,利用锁和一个变量,无论是谁竞争到锁,但是如果state不是自己对应的线程该打印的,那么这把锁也会被释放掉!然后,几个进程再去竞争同一把锁,直到竞争到锁的线程刚刚好需要打印,按序就可以完成打印的功能!
思路2
跟上面加锁差不多,这里利用信号量来做线程同步!
代码2
import java.util.concurrent.Semaphore;
public class Main{
private static Semaphore semaphore = new Semaphore(1);//只有一个线程可以获得这个资源
private static int state = 0;
public static void main(String[] args) {
new Thread(new ThreadA()).start();
new Thread(new ThreadB()).start();
new Thread(new ThreadC()).start();
}
static class ThreadA implements Runnable
{
@Override
public void run()
{
for (int i=0;i<10;)
{
try
{
semaphore.acquire();
while (state%3==0)
{
System.out.println("A");
++state;
++i;
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
finally
{
semaphore.release();
}
}
}
}
static class ThreadB implements Runnable{
@Override
public void run() {
for (int i=0;i<10;)
{
try
{
semaphore.acquire();
while (state%3==1)
{
System.out.println("B");
++state;
++i;
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
finally {
semaphore.release();
}
}
}
}
static class ThreadC implements Runnable{
@Override
public void run()
{
for (int i=0;i<10;)
{
try
{
semaphore.acquire();
while (state%3==2)
{
System.out.println("C");
++state;
++i;
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
finally
{
semaphore.release();
}
}
}
}
}
结果2
也是能够正常按序打印!
思路3
利用lock锁和condition监视器,因为这个监视器可以唤醒特定的线程(await()和signal()),相比于wait()和notify()有更大的优势!
代码3
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Main{
private static Lock lock = new ReentrantLock();
private static Condition condition1 = lock.newCondition();
private static Condition condition2 = lock.newCondition();
private static Condition condition3 = lock.newCondition();
private static int number = 1;
public static void main(String[] args) {
new Thread(new ThreadA()).start();
new Thread(new ThreadB()).start();
new Thread(new ThreadC()).start();
}
static class ThreadA implements Runnable
{
@Override
public void run() {
for (int i=0;i<10;)
{
try
{
lock.lock();
while (number!=1)
condition1.await();
number=2;
++i;
System.out.println("A");
condition2.signal();
}
catch (InterruptedException e)
{
e.printStackTrace();
} finally
{
lock.unlock();
}
}
}
}
static class ThreadB implements Runnable{
@Override
public void run() {
for (int i=0;i<10;)
{
try
{
lock.lock();
while (number!=2)
{
condition2.await();
}
number=3;
++i;
System.out.println("B");
condition3.signal();
}
catch (InterruptedException e)
{
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
static class ThreadC implements Runnable{
@Override
public void run() {
for (int i=0;i<10;)
{
try
{
lock.lock();
while (number!=3)
condition3.await();
number=1;
++i;
System.out.println("C");
condition1.signal();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
finally {
lock.unlock();
}
}
}
}
}
结果3
这种也是能够正常按照顺序输出10次ABC的!