线程同步与synchronized

看如下代码：

package project;
public class Demo {
	public static void main(String []args){
		final Out out=new Out();
		new Thread(){
			public void run(){
				int i=0;
				while(i<5){
					i++;
				out.print("1111111111");
				}
			}
		}.start();
		new Thread(){
			public void run(){
				int i=0;
				while(i<5){
					i++;
				out.print("2222222222");
				}
			}
		}.start();
	}
	

}
class Out{
	public void print(String str){
		for(int i=0;i

运行结果：

 理想的打印应该是每行只有1或2并且每行10个数字，而上面却出现了行内数字个数不为10，1中还夹杂着2。

那么出现这种现象的原因是什么呢？

线程并不是同时执行的，而是CPU快速的在这线程之间切换执行，由于切换速度极快使我们感觉同时执行罢了。

在这里，A线程在还没有执行完print()方法时，就切换到了B线程调用了print()，然后在B线程结束或者还没结束又切换到了A线程，如此反复，造成的结果。

那么怎么控制在A(或B)线程在调用print()方法时，另一个线程不调用print()方法呢？

针对线程同步问题java早就有解决方法了，最简单的就是给方法加上synchronized关键字，如下：

class Out{
	public synchronized void  print(String str){
		for(int i=0;i

这样结果就会是理想状态的结果了：

这是什么意思呢？加上synchronized关键字后，比如A线程执行print()方法就相当于拿到了一把锁，只有获取这个锁才能执行此方法，如果在A线程执行print()方法过程中B线程也想插一脚进来执行print()方法，对不起此时这是不能够的，因为此时锁在A线程手里，B线程无权拿到这把锁，只有等到A线程执行完后放弃锁，B线程才能拿到锁执行print()方法。

为print()方法加上synchronized后其就变成了同步方法，普通同步方法的锁是this,也就是当前对象，比如Demo中，外部要想调用print()方法就必须创建Out类实例对象out，此时print()同步方法的锁就是这个out。

我们还可以通过同步代码块

写法：synchronized(obj){}，其中obj为锁对象。

如这里，修改Out类：

class Out{
	public void  print(String str){
		synchronized(this){
		for(int i=0;i

这样结果还会是理想状态：

原因是在执行同步代码块里面的内容的线程 获得了锁，只有在它执行完毕后释放了锁，其他线程才能获得锁，并执行代码块里面的内容。

如上是对一个类的一个对象，里面的方法或者代码块加锁。

如果是一个类的多个对象呢？会出现什么情况？看下面一段代码：

package project;
public class Demo {
	public static void main(String []args){
		final Out out1=new Out();
		final Out out2=new Out();
		new Thread(){
			public void run(){
				int i=0;
				while(i<5){
					i++;
				out1.print("1111111111");
				}
			}
		}.start();
		new Thread(){
			public void run(){
				int i=0;
				while(i<5){
					i++;
				out2.print("2222222222");
				}
			}
		}.start();
	}
	

}
class Out{
	public void  print(String str){
		synchronized(this){
		for(int i=0;i

上面的代码了，创建了两个Out类对象，两个线程分别执行不同的对象的print()方法 。

看下运行结果：

很显然，结果并不理想，synchronized 加锁并没起作用。

原因：synchronized 的锁对象为this,也就是当前实例对象，但这里是同一个类的不同对象实例，两个线程访问的不是同一个对象，所以synchronized并不会起作用。

那么这里要怎么让synchronized起作用呢？

让synchronized锁这个类对应的Class对象。

修改Out类：

class Out{
	public void  print(String str){
		synchronized(Out.class){
		for(int i=0;i

以上将synchronized(this)改为了synchronized(Out.class)

运行结果如下：

这样加锁后，就算不是同一个类的实例对象，锁也能起作用。