java多线程基础（三）

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锁。