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;}@Overridepublic void run() {for(int i = 0 ; i < 5 ; i++){try {Thread.sleep(100);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}myList.add("ThreadA"+(i));}}}

public class ThreadB extends Thread {private MyList myList;public ThreadB(MyList myList) {this.myList = myList;}@Overridepublic void run() {for(int i = 0 ; i < 5 ; i++){try {Thread.sleep(100);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.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 blocke.printStackTrace();}myList.add(data);}return myList;}}
public class ThreadA extends Thread {private MyList myList;public ThreadA(MyList myList) {this.myList = myList;}@Overridepublic 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;}@Overridepublic 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 blocke.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 blocke.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;}@Overridepublic void run() {myServcie.method1();}}

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

public class ThreadC extends Thread {private MyServcie myServcie;public ThreadC(MyServcie myServcie) {this.myServcie = myServcie;}@Overridepublic 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锁。