1)synchronized这个修饰符不陌生.

通过synchronized这个可以生成三和中锁.

分别是:

类锁:通过对一个类方法添加synchronized修饰,例如:static synchronized method();

也可以通过synchronized(类名.class)添加同步锁,锁定该类的字节码实现.

对象锁(也称方法锁):通过对一个成员方法添加synchronized修饰,例如:synchronized method();

也可以通过synchronized(this),this代表的就是类对象

私有锁:其定义是通过自定义一个lock,例如Object lock = new Object();

在需要使用私有锁的地方,通过synchronized(lock){}进行代码同步,这种方式,可以将锁细粒度减小.使同步的同时,不至于减少太多的效率

2)有私有锁应运而生的分段锁

分段锁的概念是将一组对象,或一个集合对象,对行锁分配,面每一个锁分配一部分数据,达成更为高效的私有锁变种.

例如:我们在进行多进程操作一个HashMap时,我们可通过synchronized对操作HashMap的方法进行加锁,但是也可以将HashMap改为ConcurrentHashMap(其内部实现了分段锁机制),来实现同步.相比性能而方,肯定是ConcurrentHashMap效率要高于加了synchronized的HashMap.

3)API提供的Lock实现同步锁

java.util.concurrent.locks.Lock接口下,可以看到有三个实现类,分别是:

ReentrantLock;Condition;ReadWriteLock

分别是重入锁,条件锁与读写锁.比如我们用ReentrantLock,实现一个代码块的同步.

class X {

private final ReentrantLock lock = new ReentrantLock();

// ...

public void m() {

lock.lock(); // block until condition holds

try {

// ... method body

finally {

lock.unlock()

}

}

}}

4)通过CountDownLatch将异步线程转为同步线程.

class Driver { // ...

void main() throws InterruptedException {

CountDownLatch startSignal = new CountDownLatch(1);

CountDownLatch doneSignal = new CountDownLatch(N);

for (int i = 0; i < N; ++i) // create and start threads

new Thread(new Worker(startSignal, doneSignal)).start();

doSomethingElse(); // don't let run yet

startSignal.countDown(); // let all threads proceed

doSomethingElse();

doneSignal.await(); // wait for all to finish

}

}

class Worker implements Runnable {

private final CountDownLatch startSignal;

private final CountDownLatch doneSignal;

Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {

this.startSignal = startSignal;

this.doneSignal = doneSignal;

}

public void run() {

try {

startSignal.await();

doWork();

doneSignal.countDown();

} catch (InterruptedException ex) {} // return;

}

void doWork() { ... }