Java 线程同步

     如果一个共享资源被多个线程同时访问，可能会遭到破坏。

    下面的程序创建并启动100个线程，每个线程都往同一个账户中添加一个便士。这里定义一个

Account 类模拟账户，一个名为 AddAPennyTask 的类用来向账户里添加一便士，以及一个用于

创建和启动线程的主类。

代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AccountWithoutSync {

	private static Account account = new Account();
	
	public static void main(String[] args) {
		//创建线程池，并用 ExecutorService 接口来管理和控制线程池中的任务
		ExecutorService executor = Executors.newCachedThreadPool();
		//创建并启动100个线程
		for (int i = 0; i < 100; i++) {
			executor.execute(new AddAPennyTask());
		}
		//关闭执行器，但允许完成执行器中的任务
		executor.shutdown();
		//等待所有的任务完成
		while (!executor.isTerminated()) {
		}
		//打印结果
		System.out.println("What is balance? " + account.getBalance());
	}
	//向账户添加一便士的任务类
	private static class AddAPennyTask implements Runnable {
		@Override
		public void run() {
			account.deposit(1);
		}
	}
	//账户类
	private static class Account {
		private int balance = 0;

		public int getBalance() {
			return balance;
		}

		public void deposit(int amount) {
			int newBalance = balance + amount;
			//为了便于观察共享资源(balance)遭到破坏，让线程睡眠一会
			try {
				Thread.sleep(5);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			balance = newBalance;
		}
	}
}

看一下结果：

到底为什么？下面给出一个可能的情景：

    步骤 1 中，任务 1 从账户获取余额数目。步骤 2 中，任务 2 从账户中获取同样的余额数目。

    步骤 3 中，任务 1 向账户写入一个新余额。步骤 4 中，任务 2 也向账户写入一个新余额。

    这个情景的效果就是任务 1 什么也没做，因为在步骤 4 中，任务 2 覆盖了任务 1 的结果。

    任务 1 和任务 2 以一种会引起冲突的方式访问一个公共资源，这是多线程程序中的一个普遍问题，

被称为 竞争状态。如果一个类的对象在多线程程序中没有导致竞争状态，则称这样的类为 线程安全的。

Account 类不是线程安全的。

    为避免竞争状态，应防止多个线程同时进入程序的某一特定部分，这部分称为临界区。

    我们可以在 Account  类的 deposit 方法前面添加关键字 synchronized 以便一次只有一个线程可以

访问这个方法。

代码：

package Twenty_nine;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AccountWithoutSync {

	private static Account account = new Account();
	
	public static void main(String[] args) {
		//创建线程池，并用 ExecutorService 接口来管理和控制线程池中的任务
		ExecutorService executor = Executors.newCachedThreadPool();
		//创建并启动100个线程
		for (int i = 0; i < 100; i++) {
			executor.execute(new AddAPennyTask());
		}
		//关闭执行器，但允许完成执行器中的任务
		executor.shutdown();
		//等待所有的任务完成
		while (!executor.isTerminated()) {
		}
		//打印结果
		System.out.println("What is balance? " + account.getBalance());
	}
	//向账户添加一便士的任务类
	private static class AddAPennyTask implements Runnable {
		@Override
		public void run() {
			account.deposit(1);
		}
	}
	//账户类
	private static class Account {
		private int balance = 0;

		public int getBalance() {
			return balance;
		}
		//给临界区添加关键字 synchronized ，使 Account 类成为线程安全的
		public synchronized void deposit(int amount) {
			int newBalance = balance + amount;
			try {
				Thread.sleep(5);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			balance = newBalance;
		}
	}
}

结果：

还可以使用同步语句：

将代码中的 ：

account.deposit(1);

改为：

synchronized (account) {
				account.deposit(1);
			}

即可。