作为Java的另外一种同步机制，Lock与synchronized有很大的相似性，都可以实现多线程共用方法的同步和线程内代码块的同步。如果是实现共用方法同步，只需要在共用对象中生成一个Lock，并在共用方法的开始与结束处理使用Lock的lock与unlock方法。如果要实现线程内代码块同步，则可以给需要同步的线程传进同一个Lock，使用这个Lock实现多线程间的同步。

package test;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class Main {

public static void main(String[] args) {

Printer printer = new Printer();

new Thread(new A(printer)).start();

new Thread(new B(printer)).start();

}

}

class Printer {

Lock lock = new ReentrantLock();

public void print(String str) {

lock.lock();

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

for (int i = 0; i < 5; i++) {

System.out.println(str + i);

}

lock.unlock();

}

}

class A implements Runnable {

Printer printer = null;

public A(Printer printer) {

this.printer = printer;

}

public void run() {

while (true) {

printer.print("A");

}

}

}

class B implements Runnable {

Printer printer = null;

public B(Printer printer) {

this.printer = printer;

}

public void run() {

while (true) {

printer.print("B");

}

}

}

输出：

A0

A1

A2

A3

A4

A0

A1

A2

A3

A4

B0

B1

B2

B3

B4

A0

A1

A2

A3

A4

A0

A1

A2

A3

A4

package test;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class Main {

static Lock lock = new ReentrantLock();

public static void main(String[] args) {

new Thread(new A(lock)).start();

new Thread(new B(lock)).start();

}

}

class A implements Runnable {

private Lock lock = null;

public A(Lock lock) {

this.lock = lock;

}

public void run() {

while (true) {

System.out.println("A还没锁呢");

lock.lock();

System.out.println("A已经锁了");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

for (int i = 0; i < 5; i++) {

System.out.println("A打印：" + i);

}

lock.unlock();

System.out.println("A解除锁了");

}

}

}

class B implements Runnable {

private Lock lock = null;

public B(Lock lock) {

this.lock = lock;

}

public void run() {

while (true) {

System.out.println("B还没锁呢");

lock.lock();

System.out.println("B已经锁了");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

for (int i = 0; i < 5; i++) {

System.out.println("B打印：" + i);

}

lock.unlock();

System.out.println("B解除锁了");

}

}

}

输出：

A还没锁呢

A已经锁了

B还没锁呢

A打印：0

A打印：1

A打印：2

A打印：3

A打印：4

B已经锁了

A解除锁了

A还没锁呢

B打印：0

B打印：1

B打印：2

B打印：3

B打印：4

B解除锁了

B还没锁呢

A已经锁了

A打印：0

A打印：1

A打印：2

A打印：3

A打印：4

A解除锁了

A还没锁呢

B已经锁了

B打印：0

B打印：1

B打印：2

B打印：3

B打印：4