例1 - synchronized和volatile
package volatileTest;
public class VolatileTest01 {
volatile
int i;
// synchronized if commented out, sum will not equal to 1000
// synchronized 注释了synchronized，即使加上volatile也得不到1000的结果
public void addI(){
i++;
}
public static void main(String[] args) throws InterruptedException {
final VolatileTest01 test01 = new VolatileTest01();
for (int n = 0; n < 1000; n++) {
new Thread(new Runnable() {
public void run() {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
test01.addI();
}
}).start();
}
Thread.sleep(10000);//等待10秒，保证上面程序执行完成
System.out.println(test01.i);
}
}
缓存一致性协议——Intel 的MESI协议，保证了每个缓存中使用的共享变量的副本是一致的。它核心的思想是：当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。
例2 - CountDownLatch
package threadTest2;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolTest {
private static final int COUNT = 10;
// 每一个线程减一次1
private static class TestRunnable implements Runnable {
private final CountDownLatch countDownLatch;
private byte[] lock;
TestRunnable(CountDownLatch countDownLatch, byte[] byteArray) {
this.countDownLatch = countDownLatch;
this.lock = byteArray;
}
public void run() {
synchronized(this.lock) {
System.out.println("Thread id: " + Thread.currentThread().getId());
countDownLatch.countDown();
System.out.println("Left number: " + countDownLatch.getCount());
if( countDownLatch.getCount() == 0){
System.out.println("!!!!!!!!!! Game over!!!!!!!!!!!");
}
}
}
}
public void testThreadPool() throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(COUNT);
ExecutorService executorService = Executors.newFixedThreadPool(10);
long bg = System.currentTimeMillis();
final byte[] lock = new byte[0]; // 特殊的instance变量
for (int i = 0; i < COUNT; i++) {
Runnable command = new TestRunnable(countDownLatch, lock);
executorService.execute(command);
}
countDownLatch.await();
System.out.println("testThreadPool:"
+ (System.currentTimeMillis() - bg));
}
public void testNewThread() throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(COUNT);
long bg = System.currentTimeMillis();
final byte[] lock = new byte[0]; // 特殊的instance变量
for (int i = 0; i < COUNT; i++) {
Runnable command = new TestRunnable(countDownLatch, lock);
Thread thread = new Thread(command);
thread.start();
}
countDownLatch.await();
System.out
.println("testNewThread:" + (System.currentTimeMillis() - bg));
}
public static void main(String[] arg) {
ThreadPoolTest a = new ThreadPoolTest();
try {
// a.testThreadPool();
a.testNewThread();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
输出：
Thread id: 13
Left number: 9
Thread id: 22
Left number: 8
Thread id: 21
Left number: 7
Thread id: 20
Left number: 6
Thread id: 19
Left number: 5
Thread id: 17
Left number: 4
Thread id: 16
Left number: 3
Thread id: 18
Left number: 2
Thread id: 15
Left number: 1
Thread id: 14
Left number: 0
testNewThread:8
!!! Game over!!!
例3 - 一个死锁的例子
package thread;
public class DeadLockExample {
public static void main(String[] args) {
final String resource1 = "ABAP";
final String resource2 = "Java";
// t1 tries to lock resource1 then resource2
Thread t1 = new Thread() {
public void run() {
synchronized (resource1) {
System.out.println("Thread 1: locked resource 1");
try {
Thread.sleep(100);
} catch (Exception e) {
}
synchronized (resource2) {
System.out.println("Thread 1: locked resource 2");
}
}
}
};
Thread t2 = new Thread() {
public void run() {
synchronized (resource2) {
System.out.println("Thread 2: locked resource 2");
try {
Thread.sleep(100);
} catch (Exception e) {
}
synchronized (resource1) {
System.out.println("Thread 2: locked resource 1");
}
}
}
};
t1.start();
t2.start();
}
}
