当我们在程序中启动两个或多个线程时，可能会出现多个线程尝试访问同一资源的情况，最终由于并发问题，它们可能会产生无法预料的结果。例如，如果多个线程试图在同一文件中写入数据，则它们可能会破坏数据，因为其中一个线程可以覆盖数据，或者一个线程同时打开同一文件时，另一个线程可能正在关闭同一文件。
因此，需要同步多个线程的操作，并确保在给定的时间点只有一个线程可以访问资源。这是使用称为Monitors的概念实现的。Java中的每个对象都与一个监视器关联，线程可以锁定或解锁监视器。一次只能有一个线程在监视器上保持锁。
Java编程语言提供了一种非常方便的方式来创建线程并通过使用同步块来同步其任务。您将共享资源保留在此块内。以下是同步语句的一般形式。
synchronized(objectidentifier) {
//访问共享变量和其他共享资源
}在这里，objectidentifier是对对象的引用，该对象的锁与同步语句表示的监视器相关联。现在，我们将看到两个示例，其中将使用两个不同的线程打印计数器。当线程不同步时，它们将不按顺序打印计数器值，但是当我们通过放在内部synchronized()块中来打印计数器时，则两个线程都将按顺序非常大量地打印计数器。
这是一个简单的示例，它可以按顺序打印计数器值，也可以不按顺序打印，并且每次运行它时，它都会基于线程的CPU可用性而产生不同的结果。
class PrintDemo extends Thread {
public void printCount() {
try {
for(int i = 5; i > 0; i--) {
System.out.println("Counter --- " + i );
}
} catch (Exception e) {
System.out.println("Thread " + Thread.currentThread().getName()+" interrupted.");
}
}
public void run() {
printCount();
System.out.println("Thread " + Thread.currentThread().getName() + " exiting.");
}
}
public class TestThread {
public static void main(String args[]) {
PrintDemo PD = new PrintDemo();
Thread t1 = new Thread(PD );
Thread t2 = new Thread(PD );
t1.start();
t2.start();
//等待线程结束
try {
t1.join();
t2.join();
} catch ( Exception e) {
System.out.println("Interrupted");
}
}
}每次您运行该程序时，都会产生不同的结果。
输出结果
Counter --- 5 Counter --- 5 Counter --- 4 Counter --- 4 Counter --- 3 Counter --- 3 Counter --- 2 Counter --- 2 Counter --- 1 Counter --- 1 Thread Thread-1 exiting. Thread Thread-2 exiting.
这是相同的示例，它按顺序打印计数器值，并且每次运行它时，它都会产生相同的结果。我们已将synced关键字放在一个块上，以便现在在方法执行期间根据对象锁定计数器增量代码。我们使用当前对象作为锁，我们将同步块作为参数传递。
class PrintDemo extends Thread {
public void printCount() {
try {
for(int i = 5; i > 0; i--) {
System.out.println("Counter --- " + i );
}
} catch (Exception e) {
System.out.println("Thread " + Thread.currentThread().getName()+" interrupted.");
}
}
public void run() {
synchronized(this) {
printCount();
}
System.out.println("Thread " + Thread.currentThread().getName() + " exiting.");
}
}
public class TestThread {
public static void main(String args[]) {
PrintDemo PD = new PrintDemo();
Thread t1 = new Thread(PD );
Thread t2 = new Thread(PD );
t1.start();
t2.start();
//等待线程结束
try {
t1.join();
t2.join();
} catch ( Exception e) {
System.out.println("Interrupted");
}
}
}每次您运行该程序时，都会产生相同的结果。
输出结果
Counter --- 5 Counter --- 4 Counter --- 3 Counter --- 2 Counter --- 1 Counter --- 5 Counter --- 4 Counter --- 3 Counter --- 2 Counter --- 1 Thread Thread-2 exiting. Thread Thread-1 exiting.
这是相同的示例，它按顺序打印计数器值，并且每次运行它时，它都会产生相同的结果。这次我们在方法上放置了synced关键字，以便在方法执行期间根据对象锁定完整的方法。
class PrintDemo extends Thread {
public void printCount() {
try {
for(int i = 5; i > 0; i--) {
System.out.println("Counter --- " + i );
}
} catch (Exception e) {
System.out.println("Thread " + Thread.currentThread().getName()+" interrupted.");
}
}
public synchronized void run() {
printCount();
System.out.println("Thread " + Thread.currentThread().getName() + " exiting.");
}
}
public class TestThread {
public static void main(String args[]) {
PrintDemo PD = new PrintDemo();
Thread t1 = new Thread(PD );
Thread t2 = new Thread(PD );
t1.start();
t2.start();
//等待线程结束
try {
t1.join();
t2.join();
} catch ( Exception e) {
System.out.println("Interrupted");
}
}
}每次您运行该程序时，都会产生相同的结果。
输出结果
Counter --- 5 Counter --- 4 Counter --- 3 Counter --- 2 Counter --- 1 Thread Thread-1 exiting. Counter --- 5 Counter --- 4 Counter --- 3 Counter --- 2 Counter --- 1 Thread Thread-2 exiting.