JAVA Synchronized 详解（一）

最新推荐文章于 2022-10-09 16:54:14 发布

独自等待_T

最新推荐文章于 2022-10-09 16:54:14 发布

阅读量3.1k

点赞数

分类专栏： JAVA 基础文章标签： java Java JAVA synchronized 同步

本文链接：https://blog.csdn.net/smilevt/article/details/8276806

版权

JAVA 基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

使用synchronized

在编写一个类时，如果该类中的代码可能运行于多线程环境下，那么就要考虑同步的问题。

在Java中内置了语言级的同步原语－－synchronized，这也大大简化了Java中多线程同步的使用。

我们首先编写一个非常简单的多线程的程序，是模拟银行中的多个线程同时对同一个储蓄账户进行存款、取款操作的；在程序中我们使用了一个简化版本的Account类，代表了一个银行账户的信息；在主程序中我们首先生成了1000个线程，然后启动它们，每一个线程都对John的账户进行存100元，然后马上又取出100元。这样，对于John的账户来说，最终账户的余额应该是还是1000元才对。然而运行的结果却超出我们的想像，首先来看看我们的演示代码：

package com.sync.test;

public class Account {
        String name;
	float amount;

	public Account(String name, float amount) {
		this.name = name;
		this.amount = amount;
	}

	public void inAccount(float amt) {
		float tmp = amount;
		tmp += amt;

		try {
			Thread.sleep((int) (Math.random() * 1000));// 模拟其它处理所需要的时间，比如刷新数据库等
		} catch (InterruptedException e) {
			System.out.println("inAccount excetion: " + e.toString());
		}
		amount = tmp;
	}

	public void outAccount(float amt) {
		float tmp = amount;
		tmp -= amt;
		try {
			Thread.sleep((int) (Math.random() * 1000));// 模拟其它处理所需要的时间，比如刷新数据库等
		} catch (InterruptedException e) {
			System.out.println("outAccount excetion: " + e.toString());
		}
		amount = tmp;
	}

	public float getBalance() {
		return amount;
	}
}

package com.sync.test;

public class AccountTest {

	private static int NUM_OF_THREAD = 1000;
	static Thread[] threads = new Thread[NUM_OF_THREAD];

	public static void main(String[] args) throws Exception {

		final Account acc = new Account("John", 1000.0f);

		for (int i = 0; i < NUM_OF_THREAD; i++) {
			threads[i] = new Thread(new Runnable() {
				public void run() {
					acc.inAccount(100.0f);
					acc.outAccount(100.0f);
				}
			});
			threads[i].start();
		}

		for (int i = 0; i < NUM_OF_THREAD; i++) {
			try {
				threads[i].join(); // 等待所有线程运行结束
			} catch (InterruptedException e) {
				System.out.println("threads[" + i + "] excetion: " + e.toString());
			}
		}
		System.out.println("Finally, John's balance is:" + acc.getBalance());
	}

}

注意：上面在Account的inAccount和outAccount方法中之所以要把对amount的运算使用一个临时变量首先存储，随机sleep一段时间，然后，再赋值给amount，是为了模拟真实运行时的情况。因为在真实系统中，账户信息肯定是存储在持久媒介中，比如RDBMS中，此处的睡眠的时间相当于比较耗时的数据库操作，最后把临时变量tmp的值赋值给amount相当于把amount的改动写入数据库中。

运行AccountTest，结果如下（每一次结果都会不同）：
Finally, John's balance is:1200.0

为什么会出现这样的问题？
这就是多线程中的同步的问题。在我们的程序中，Account中的amount会同时被多个线程所访问，这就是一个竞争资源，通常称作竞态条件。对于这样的多个线程共享的资源我们必须进行同步，以避免一个线程的改动被另一个线程所覆盖。
在我们这个程序中，Account中的amount是一个竞态条件，所以所有对amount的修改访问都要进行同步，我们将inAccount()和outAccount()方法进行同步，
修改为：

	public synchronized  void inAccount(float amt) {
		float tmp = amount;
		tmp += amt;

		try {
			Thread.sleep((int)(Math.random()*1000)); // 模拟其它处理所需要的时间，比如刷新数据库等
		} catch (InterruptedException e) {
			System.out.println("inAccount excetion: " + e.toString());
		}

		amount = tmp;
	}

	public synchronized void outAccount(float amt) {
		float tmp = amount;
		tmp -= amt;

		try {
			Thread.sleep((int)(Math.random()*1000)); // 模拟其它处理所需要的时间，比如刷新数据库等
		} catch (InterruptedException e) {
			System.out.println("outAccount excetion: " + e.toString());
		}

		amount = tmp;
	}

此时，再运行，我们就能够得到正确的结果了。Account中的getBalance()也访问了amount，为什么不对getBalance()同步呢？因为getBalance()并不会修改amount的值，所以，同时多个线程对它访问不会造成数据的混乱。

同步加锁的是对象，而不是代码。
因此，如果你的类中有一个同步方法，这个方法可以被两个不同的线程同时执行，只要每个线程自己创建一个的该类的实例即可。
参考下面的代码：

package com.sync.test;

public class Foo extends Thread {
	private int val;

	public Foo(int v) {
		val = v;
	}

	public synchronized void printVal(int v) {
		while (true)
			System.out.println(v);
	}

	public void run() {
		printVal(val);
	}

}

package com.sync.test;

public class FooTest {

	public static void main(String[] args) {
		Foo f1 = new Foo(1);
		f1.start();
		Foo f2 = new Foo(3);
		f2.start();
	}
}

运行FooTest产生的输出是1和3交叉的。如果printVal是断面，你看到的输出只能是1或者只能是3而不能是两者同时出现。程序运行的结果证明两个线程都在并发的执行printVal方法，即使该方法是同步的并且由于是一个无限循环而没有终止。

类的同步：
要实现真正的断面，你必须同步一个全局对象或者对类进行同步。
下面的代码给出了一个这样的范例：

package com.sync.test;

public class Foo extends Thread {
	private int val;

	public Foo(int v) {
		val = v;
	}

	public void printVal(int v) {
		synchronized (Foo.class) {
			while (true)
				System.out.println(v);
		}
	}

	public void run() {
		printVal(val);
	}

}

上面的类不再对个别的类实例同步而是对类进行同步。

对于类Foo而言，它只有唯一的类定义，两个线程在相同的锁上同步，因此只有一个线程可以执行printVal方法。

这个代码也可以通过对公共对象加锁。例如给Foo添加一个静态成员。两个方法都可以同步这个对象而达到线程安全。

同步公共对象的两种通常方法：

第一种

package com.sync.test;

public class Foo extends Thread {
	private int val;
	private static Object lock = new Object();

	public Foo(int v) {
		val = v;
	}

	public void printVal(int v) {
		synchronized (lock) {
			while (true) {
				System.out.println(v);
			}
		}
	}

	public void run() {
		printVal(val);
	}
}

上面的这个例子比原文给出的例子要好一些，因为原文中的加锁是针对类定义的，一个类只能有一个类定义，而同步的一般原理是应该尽量减小同步的粒度以到达更好的性能。笔者给出的范例的同步粒度比原文的要小。

第二种

package com.sync.test;

public class Foo extends Thread {
	private String name;
	private String val;

	public Foo(String name, String v) {
		this.name = name;
		val = v;
	}

	public void printVal() {
		synchronized (val) {
			while (true){
				System.out.println(name + val);
			}
		}
	}

	public void run() {
		printVal();
	}
}

package com.sync.test;

public class FooTest {

	public static void main(String[] args) {
		Foo f1 = new Foo("Foo 1:", "printVal");
		f1.start();
		Foo f2 = new Foo("Foo 2:", "printVal");
		f2.start();
	}
}

上面这个代码需要进行一些额外的说明，因为JVM有一种优化机制，因为String类型的对象是不可变的，因此当你使用""的形式引用字符串时，如果JVM发现内存已经有一个这样的对象，那么它就使用那个对象而不再生成一个新的String对象，这样是为了减小内存的使用。

上面的main方法其实等同于：

public static void main(String[] args) {
	String value = "printVal";
	Foo f1 = new Foo("Foo 1:", value);
	f1.start();
	Foo f2 = new Foo("Foo 2:", value);
	f2.start();
}

总结：

        1、synchronized关键字的作用域有二种：
               （1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
               （2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象；

3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用.