內建同步塊，同步方法：
public static class Syn {
synchronized void funA() throws InterruptedException {
wait();
System.out.println("synchronized functionA()");
}
void funB() {
synchronized (MyThread.Syn.this) {
System.out.println("synchronized functionB()");
notifyAll();
}
}
Runnable instanceA() {
return new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
funA();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
}
Runnable instanceB() {
return new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
funB();
}
};
}
public static void main(String[] args) {
Syn syn = new Syn();
new Thread(syn.instanceA()).start();
new Thread(syn.instanceB()).start();
}
}
wait(),notify()只能在同步塊或方法中執行，否則拋出InterruptedException
同步鎖lock提供lock,unlock,trylock,lock.lockInterruptibly();注意應該在finally塊中釋放鎖
內置condition類，可以實現更復雜的控制（參見實例），它提供了類似wait/notify的功能，signal/await，必須在condition的lock塊中使用。
read，lock鎖，可以實現一個讀取並行，寫入串行的鎖
static public class LockTest {
Lock lock = new ReentrantLock();
Condition conditionEmpty = lock.newCondition();
Condition conditionFull = lock.newCondition();
ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
Lock readLock = readWriteLock.readLock();
Lock writeLock = readWriteLock.writeLock();
ArrayList<String> arrayList = new ArrayList<>();
int max = 1000;
String getCommonLock(int i) {
lock.lock();
try {
return arrayList.get(i);
} finally {
lock.unlock();
}
}
void setCommonLock(String string) {
lock.lock();
try {
arrayList.add(string);
} finally {
lock.unlock();
}
}
String remove(int i) throws InterruptedException {
lock.lock();
try {
while (arrayList.size() == 0) {
conditionEmpty.await();
}
conditionFull.signalAll();
return arrayList.remove(i);
} finally {
lock.unlock();
}
}
void insert(String string) throws InterruptedException {
lock.lock();
try {
while (arrayList.size() == 0) {
conditionFull.await();
}
conditionEmpty.signalAll();
arrayList.add(string);
} finally {
lock.unlock();
}
}
String getReadLock(int i) {
readLock.lock();
try {
return arrayList.get(i);
} finally {
readLock.unlock();
}
}
void setWriteLock(String string) {
writeLock.lock();
try {
arrayList.add(string);
} finally {
writeLock.unlock();
}
}
}
同步類：blockQueue，contrunt****簡單略去，注意的是他們使用lock機制實現了鎖定，因此當使用java內部鎖鎖定同步類本身時不能實現對象分佈
CountDownLatch/CyclicBarrier，用以控制各個線程到達同一位置後繼續執行，提供線程間協調方法
Semaphore，用來發布可以被n各線程訪問的資源（lock發佈了一個可以被一個線程訪問的資源）