package practice;
public class T1 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new MyThread("a"));
Thread t2 = new Thread(new MyThread("b"));
Thread t3 = new Thread(new MyThread("c"));
t1.start();
t1.join();
t2.start();
t2.join();
t3.start();
t3.join();
}
static class MyThread implements Runnable {
String str;
public MyThread(String str) {
this.str = str;
}
@Override
public void run() {
System.out.println(str);
try {
Thread.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(str + "end");
}
}
}
- 2 三个线程顺序打出abc 30次[Semaphore]
package practice;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
public class T1 {
static AtomicInteger count = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {
Semaphore sem_a = new Semaphore(0);
Semaphore sem_b = new Semaphore(0);
Semaphore sem_c = new Semaphore(0);
Thread t1 = new Thread(new MyThread("a", sem_a, sem_b));
Thread t2 = new Thread(new MyThread("b", sem_b, sem_c));
Thread t3 = new Thread(new MyThread("c", sem_c, sem_a));
t1.start();
t2.start();
t3.start();
sem_a.release();
}
static class MyThread implements Runnable {
String str;
Semaphore self, next;
public MyThread(String str, Semaphore selft, Semaphore next) {
this.str = str;
this.self = selft;
this.next = next;
}
@Override
public void run() {
while (true) {
try {
self.acquire();
} catch (InterruptedException e) {
e.printStackTrace();
}
count.addAndGet(1);
if (count.get() / 10 >= 3) {
next.release();
break;
} else {
System.out.println(count.get() + ":" + str);
next.release();
}
}
}
}
}
- 3 三个线程顺序打出abc 30次[Synchronized, wait, notifyall]
package practice;
public class T2 {
static int count = 0;
static int currentIndex = 0;
public static void main(String[] args) {
Object lock = new Object();
Thread t1 = new Thread(new MyThread(lock, 0, "a"));
Thread t2 = new Thread(new MyThread(lock, 1, "b"));
Thread t3 = new Thread(new MyThread(lock, 2, "c"));
t1.start();
t2.start();
t3.start();
}
static class MyThread implements Runnable {
Object lock;
int index;
String string;
public MyThread(Object lock, int index, String str) {
this.lock = lock;
this.index = index;
this.string = str;
}
@Override
public void run() {
while (true) {
synchronized (lock) { //gain the lock
while (index != currentIndex && count <= 29) {// if it is not, release the lock.
try {
lock.wait(); // The current thread must own this object's monitor, that's why it is in synchronized block
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//gained the lock and do the business
if (count > 29) {
lock.notifyAll();
break;
}
System.out.println(count + ":" + string);
count++;
currentIndex = (currentIndex + 1) % 3;
lock.notifyAll();// let's ask for the lock together. A thread waits on an object's monitor by calling one of the wait methods.
}
}
}
}
}
- 3 三个线程顺序打出abc 30次[Lock, Condition]
package practice;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//Condition 实现可以提供不同于 Object 监视器方法的行为和语义，比如受保证的通知排序，或者在执行通知时不需要保持一个锁。
public class T3 {
static ReentrantLock lock = new ReentrantLock();
static Condition cona = lock.newCondition();
static Condition conb = lock.newCondition();
static Condition conc = lock.newCondition();
static int count = 0;
static int currentIndex = 0;
public static void main(String[] args) {
Thread threada = new Thread(new MyThread(lock, cona, conb, "a", 0));
Thread threadb = new Thread(new MyThread(lock, conb, conc, "b", 1));
Thread threadc = new Thread(new MyThread(lock, conc, cona, "c", 2));
threada.start();
threadb.start();
threadc.start();
}
static class MyThread implements Runnable {
Condition self, next;
String str;
int index;
Lock lock;
public MyThread(Lock lock, Condition self, Condition next, String str, int index) {
this.lock = lock;
this.self = self;
this.next = next;
this.str = str;
this.index = index;
}
@Override
public void run() {
while (true) {
try {
lock.lock();
while (index != currentIndex && count < 30) {
try {
self.await(); //与此 Condition 相关的锁以原子方式释放，并且出于线程调度的目的，将禁用当前线程. 但是可能出现虚假唤醒,所以还是while
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (count >= 30) {
next.signal();
break;
}
System.out.println(count + ":" + str);
count++;
currentIndex = (currentIndex + 1) % 3;
next.signal();
} finally {
lock.unlock();
}
}
}
}
}
