线程同步与synchronized

小咪咪 2022-05-10 04:38 242阅读 0赞

看如下代码：

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<str.length();i++){
    			System.out.print(str.charAt(i));
    		}
    		System.out.println();
    	}
    }

运行结果：

![70][]

理想的打印应该是每行只有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<str.length();i++){
    			System.out.print(str.charAt(i));
    		}
    		System.out.println();
    	}
    }

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

![70 1][]

这是什么意思呢？加上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<str.length();i++){
    			System.out.print(str.charAt(i));
    		}
    		System.out.println();
    		}
    	}
    }

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

![70 2][]

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

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

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

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<str.length();i++){
    			System.out.print(str.charAt(i));
    		}
    		System.out.println();
    		}
    	}
    }

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

看下运行结果：

![70 3][]

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

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

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

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

修改Out类：

class Out{
    	public void  print(String str){
    		synchronized(Out.class){
    		for(int i=0;i<str.length();i++){
    			System.out.print(str.charAt(i));
    		}
    		System.out.println();
    		}
    	}
    }

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

运行结果如下：

![70 4][]

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

[70]: /images/20220510/492f3a519fd3461c853818498520d796.png
[70 1]: /images/20220510/5adbedff530646779752af17cab2ed80.png
[70 2]: /images/20220510/1418967ca0c0479fb99b53b42cffc925.png
[70 3]: /images/20220510/f0c85de153164a87b70f3e8d455857dd.png
[70 4]: /images/20220510/73d4264906a24f58a4afe7cb7cb35fce.png