多线程与并发----线程互斥技术

柔光的暖阳◎ 2021-09-15 09:42 426阅读 0赞

1、使用synchronized代码块

2、使用synchronized方法

3、分析静态方法锁使用的同步监视器对象是什么？

4、wait与notify实现线程间的通信

**例一：使用内部类和两个线程交替不停的打印lisi和zhangsan两个名字**

public class ThreadSynchronized {
    
    	public static void main(String[] args) {
    		
    		new ThreadSynchronized().init();
    	}
    	
    	public void init(){
    		/*在静态方法中不能new内部类的实例对象，
    		因为内部类的最重要的一个特点就是它可以直接访问它外部类的成员变量。成员变量是对象身上的。对象创建完成了,才会为成员变量分配空间。能调用成员变量,意味着一定有了实例对象.
    		main方法是静态的，它执行的时候可以不用创建那个对象。这就矛盾了。 
    		 */
    		final Outputer outputer=new Outputer();//创建内部类
    		new Thread(new Runnable() {//创建一个线程
    			public void run() {
    				while(true){
    					try {
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					
    					outputer.output("lisi");
    				}
    				
    			}
    		}).start();
    		
    		new Thread(new Runnable() {//创建一个线程
    			public void run() {
    				while(true){
    					try {
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					
    					outputer.output("zhangsan");
    				}
    				
    			}
    		}).start();
    	}
    		
    	//内部类
    	class Outputer{
    		public void output(String name){
    			int len=name.length();
    			synchronized (name)
    			{
    				for(int i=0;i<len;i++){
    					System.out.print(name.charAt(i));
    				}
    				System.out.println();
    			}
    		}
    	}
    }

运行结果为：

> > lisi  
> > zhangsan  
> > zhangsan  
> > lisi  
> > lisi  
> > zhangsan  
> > lisi  
> >

**使用synchronized代码块**

public class ThreadSynchronized {
    
    	public static void main(String[] args) {
    		
    		new ThreadSynchronized().init();
    	}
    	
    	public void init(){
    		/*在静态方法中不能new内部类的实例对象，
    		因为内部类的最重要的一个特点就是它可以直接访问它外部类的成员变量。成员变量是对象身上的。对象创建完成了,才会为成员变量分配空间。能调用成员变量,意味着一定有了实例对象.
    		main方法是静态的，它执行的时候可以不用创建那个对象。这就矛盾了。 
    		 */
    		final Outputer outputer=new Outputer();//创建内部类
    		new Thread(new Runnable() {//创建一个线程
    			public void run() {
    				while(true){
    					try {
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					
    					outputer.output("lisi");
    				}
    				
    			}
    		}).start();
    		
    		new Thread(new Runnable() {//创建一个线程
    			public void run() {
    				while(true){
    					try {
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					
    					outputer.output("zhangsan");
    				}
    				
    			}
    		}).start();
    	}
    		
    	//内部类
    	class Outputer{
    		public void output(String name){
    			int len=name.length();
    			synchronized (this)
    			{
    				for(int i=0;i<len;i++){
    					System.out.print(name.charAt(i));
    				}
    				System.out.println();
    			}
    		}
    	}
    }

**使用synchronized方法**

public class ThreadSynchronized {
    
    	public static void main(String[] args) {
    		
    		new ThreadSynchronized().init();
    	}
    	
    	public void init(){
    		/*在静态方法中不能new内部类的实例对象，
    		因为内部类的最重要的一个特点就是它可以直接访问它外部类的成员变量。成员变量是对象身上的。对象创建完成了,才会为成员变量分配空间。能调用成员变量,意味着一定有了实例对象.
    		main方法是静态的，它执行的时候可以不用创建那个对象。这就矛盾了。 
    		 */
    		final Outputer outputer=new Outputer();//创建内部类
    		new Thread(new Runnable() {//创建一个线程
    			public void run() {
    				while(true){
    					try {
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					
    					outputer.output("lisi");
    				}
    				
    			}
    		}).start();
    		
    		new Thread(new Runnable() {//创建一个线程
    			public void run() {
    				while(true){
    					try {
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					
    					outputer.output("zhangsan");
    				}
    				
    			}
    		}).start();
    	}
    		
    	//内部类
    	class Outputer{
    		public synchronized void output(String name){
    			int len=name.length();
    				for(int i=0;i<len;i++){
    					System.out.print(name.charAt(i));
    				}
    				System.out.println();
    		}
    	}
    }

![20180508172624998][]

**例子：子线程循环10次和主线程循环10次，两者实现同步**

** 例子：子线程循环10次和主线程循环10次，两者交替运行50次的例子**

public class ThreadCommunication {
    
    	public static void main(String[] args) {
    		
    		final Business business=new Business();
    		
    		new Thread(new Runnable() {
    			
    			public void run() {
    				for(int i=0;i<50;i++){	
    						business.sub(i);
    				}
    				
    			}
    			
    		}).start();
    		
    		for(int i=0;i<50;i++){
    			business.main(i);
    		}
    	}
    }
    
    class Business{
    	private boolean bSholdSub=true;
    	public synchronized void sub(int i){
    		if(!bSholdSub){
    			try {
    				this.wait();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		for(int j=0;j<10;j++){
    			System.out.println("sub thread sequence of"+j+",loop of"+i);
    		}
    		bSholdSub=false;
    		this.notify();
    		
    	}
    	
    	public synchronized void main(int i){
    		if(bSholdSub){
    			try {
    				this.wait();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		for(int j=0;j<10;j++){
    			System.out.println("main thread sequence of"+j+",loop of"+i);
    		}
    		bSholdSub=true;
    		this.notify();
    	}
    }

**运行结果为：**

> > **sub thread sequence of0,loop of0  
> > sub thread sequence of1,loop of0  
> > sub thread sequence of2,loop of0  
> > sub thread sequence of3,loop of0  
> > sub thread sequence of4,loop of0  
> > sub thread sequence of5,loop of0  
> > sub thread sequence of6,loop of0  
> > sub thread sequence of7,loop of0  
> > sub thread sequence of8,loop of0  
> > sub thread sequence of9,loop of0  
> > main thread sequence of0,loop of0  
> > main thread sequence of1,loop of0  
> > main thread sequence of2,loop of0  
> > main thread sequence of3,loop of0  
> > main thread sequence of4,loop of0  
> > main thread sequence of5,loop of0  
> > main thread sequence of6,loop of0  
> > main thread sequence of7,loop of0  
> > main thread sequence of8,loop of0**  
> > 
> > 
> > **main thread sequence of9,loop of0**
> > 
> > **sub thread sequence of0,loop of0**  
> >

**为了观察程序的运行结果，可以在myeclipse中设置运行对话框，让结果重定向到一个文本文件，然后去查看该文本文件中的特殊行号是否正好对应了线程的切换点。**

**    RUN AS-->Run Configurations-->右边Common-->File前面打钩，--》输入路径，比如输入C:\\Users\\Administrator\\Desktop\\1.txt，最后点击run，就可在选择路径下看到运行程序的结果。**

**![20180510215051947][]**

**经验：要用到共同数据（包括同步锁）的若干个方法应该归在同一个类上，这个设计正好体现了高内聚和程序的健壮性。**

[20180508172624998]: /images/20210720/579a3d07930a49eaaa08f5b79b7cfc1e.png
[20180510215051947]: https://img-blog.csdn.net/20180510215051947