java多线程基础（三）

我就是我 2022-06-16 12:56 226阅读 0赞

## synchronized关键字 ##

涉及到共享资源的读写访问，在同步时，往往会使用synchronized关键字，synchronized对象监视器既可以是对象，也可以是类。

### 1 synchronized应用于非静态方法 ###

① synchronized关键字修饰方法，取的锁是对象锁。当然这个对象锁只能是是方法所在类本身对象。多个线程访问某一对象中某synchronized同步方法时，需要顺序执行。如果对象中有多个方法被synchronized关键字修饰，比如A类中有AA、BB两个方法，那么多线程不管访问哪个方法，都需要依次顺序执行，因为调用AA、BB任意一方法时都获得了A类对象锁，其他线程只有等此线程释放A类对象锁之后，才能再次取得锁并且调用同步方法。（非同步方法，随时调用，随时执行）。

② synchronized块中，锁对象既可以是所在类本身对象，也可以是其他对象。

总结：a、synchronized同步方法：对其他synchronized同步方法调用呈阻塞状态；同一时间只能有一个线程可以执行synchronized同步方法中的代码。

b 、1）synchronized（this）同步代码块：对其他synchronized（this）同步代码块调用呈阻塞状态；同一时间只有一个线程可以调用synchronized（this）同步代码块中的代码。

2）synchronized（非this对象）同步代码块：当多个线程持有“对象监视器”为同一个对象的前提下，同一时间只有一个线程可以执行synchronized（非this对象）同步代码块中的代码。

注意：同步代码块放在非同步方法中进行声明，并不能保证调用方法的线程执行是同步的，即虽然在同步块中执行顺序是同步的，但线程调用方法的顺序是无序的，这就极易出现脏读。

举例：（1）首先验证同步代码块放在非同步方法中进行声明，线程调用方法的顺序是无序的。

public class MyList {
    	private List<String> list = new ArrayList<>();
    	public synchronized void add(String username){
    		System.out.println(Thread.currentThread().getName()+"线程执行了add方法！");
    		list.add(username);
    		System.out.println(Thread.currentThread().getName()+"线程退出了add方法！");
    	}
    }

public class ThreadA extends Thread {
    
    	private MyList myList;
    	
    	public ThreadA(MyList myList) {
    		this.myList = myList;
    	}
    
    	@Override
    	public void run() {
    		for(int i = 0 ; i < 5 ; i++){
    			try {
    				Thread.sleep(100);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			myList.add("ThreadA"+(i));
    		}
    	}
    }

public class ThreadB extends Thread {
    
    	private MyList myList;
    	
    	public ThreadB(MyList myList) {
    		this.myList = myList;
    	}
    
    	@Override
    	public void run() {
    		for(int i = 0 ; i < 5 ; i++){
    			try {
    				Thread.sleep(100);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			myList.add("ThreadB"+(i));
    		}
    	}
    }

public class MainTest {
    
    	public static void main(String[] args) {
    		MyList myList = new MyList();
    		ThreadA threadA = new ThreadA(myList);
    		threadA.setName("AA");
    		threadA.start();
    		ThreadB threadB = new ThreadB(myList);
    		threadB.setName("BB");
    		threadB.start();
    	}
    }

测试结果：

AA线程执行了add方法！
    AA线程退出了add方法！
    BB线程执行了add方法！
    BB线程退出了add方法！
    AA线程执行了add方法！
    BB线程执行了add方法！
    AA线程退出了add方法！
    BB线程退出了add方法！

。。。。。。

（2）验证 验证同步代码块放在非同步方法中进行声明，因为线程调用方法的顺序是无序的，容易出现脏读

public class MyList {
    	
    	private List<String> list = new ArrayList<>();
    	public synchronized void add(String username){
    		list.add(username);
    	}
    	
    	public synchronized int getSize(){
    		return list.size();
    	}
    }

public class MyServcie {
    	public MyList addService(MyList myList , String data){
    		if(myList.getSize() < 1){
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			myList.add(data);
    		}
    		return myList;
    	}
    }
     
     public class ThreadA extends Thread {
    
    	private MyList myList;
    	
    	public ThreadA(MyList myList) {
    		this.myList = myList;
    	}
    
    	@Override
    	public void run() {
    		MyServcie myServcie = new MyServcie();
    		myServcie.addService(myList, "A");
    	}
    }
     
     public class ThreadB extends Thread {
    
    	private MyList myList;
    	
    	public ThreadB(MyList myList) {
    		this.myList = myList;
    	}
    
    	@Override
    	public void run() {
    		MyServcie myServcie = new MyServcie();
    		myServcie.addService(myList, "B");
    	}
    }
     
     public class MainTest {
    
    	public static void main(String[] args) throws InterruptedException {
    		MyList myList = new MyList();
    		ThreadA threadA = new ThreadA(myList);
    		threadA.setName("AA");
    		threadA.start();
    		ThreadB threadB = new ThreadB(myList);
    		threadB.setName("BB");
    		threadB.start();
    		Thread.sleep(5000);
    		System.out.println("list的大小是："+myList.getSize());
    	}
    }
     
    最后结果是：

list的大小是：2

解决方法：

public class MyServcie {
    
    	public  MyList addService(MyList list,String data){
    		synchronized (list) {
    			if(list.getSize() < 1){
    				try {
    					Thread.sleep(2000);
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    				list.add(data);
    			}
    		}
    		return list;
    	}
    }

在MyServcie的addService方法内部加上一个synchronized同步代码块即可。

### 2 synchronized应用于静态方法 ###

synchronized关键字加到static方法上，与synchronized关键字加到非static方法上，是有本质区别的，前者是给class类上锁，后者是给对象上锁。

举例：

public class MyServcie {
    
    	public synchronized static void method1(){
    		System.out.println(Thread.currentThread().getName()+"线程进入method1方法");
    		try {
    			Thread.sleep(3000);
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		System.out.println(Thread.currentThread().getName()+"线程退出method1方法");
    	}
    	
    	public synchronized static void method2(){
    		System.out.println(Thread.currentThread().getName()+"线程进入method2方法");
    		System.out.println(Thread.currentThread().getName()+"线程退出method2方法");
    	}
    	
    	public synchronized void method3(){
    		System.out.println(Thread.currentThread().getName()+"线程进入method3方法");
    		System.out.println(Thread.currentThread().getName()+"线程退出method3方法");
    	}
    }

public class ThreadA extends Thread {
    
    	private MyServcie myServcie;
    	
    	public ThreadA(MyServcie myServcie) {
    		this.myServcie = myServcie;
    	}
    
    	@Override
    	public void run() {
    		myServcie.method1();
    	}
    }

public class ThreadB extends Thread {
    
    private MyServcie myServcie;
    	
    	public ThreadB(MyServcie myServcie) {
    		this.myServcie = myServcie;
    	}
    
    	@Override
    	public void run() {
    		myServcie.method2();
    	}
    }

public class ThreadC extends Thread {
    
    private MyServcie myServcie;
    	
    	public ThreadC(MyServcie myServcie) {
    		this.myServcie = myServcie;
    	}
    
    	@Override
    	public void run() {
    		myServcie.method3();
    	}
    }

public class MainTest {
    
    	public static void main(String[] args) throws InterruptedException {
    		MyServcie myServcie = new MyServcie();
    		ThreadA threadA = new ThreadA(myServcie);
    		threadA.setName("AA");
    		threadA.start();
    		ThreadB threadB = new ThreadB(myServcie);
    		threadB.setName("BB");
    		threadB.start();
    		ThreadC threadC = new ThreadC(myServcie);
    		threadC.setName("CC");
    		threadC.start();
    	}
    }

测试结果：

AA线程进入method1方法
    CC线程进入method3方法
    CC线程退出method3方法
    AA线程退出method1方法
    BB线程进入method2方法
    BB线程退出method2方法

分析：异步的原因是持有不同的锁，一个是对象锁，一个是class锁。