synchronized同步方法《二》

1.synchronized方法和锁对象

（1）、验证线程锁的是对象

代码如下：

1.1创建一个MyObject类：

package edu.ymm.about_thread4;public class Myobject {public void methodA() {
try {
System.out.println("begin methodA threadName="
+ Thread.currentThread().getName());
Thread.sleep(5000);
System.out.println("end");
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}

1.2创建一个ThreadA类：

package edu.ymm.about_thread4;public class ThreadA extends Thread {private Myobject myobject;
public ThreadA(Myobject myobject) {
super();
this.myobject = myobject;
}@Override
public void run() {
super.run();
myobject.methodA();
}}

1.3创建一个ThreadB类：

package edu.ymm.about_thread4;public class ThreadB extends Thread {private Myobject myobject;
public ThreadB(Myobject myobject) {
super();
this.myobject = myobject;
}@Override
public void run() {
super.run();
myobject.methodA();
}}

1.4创建一个Test测试类：

package edu.ymm.about_thread4;public class Test {public static void main(String[] args) {Myobject myobject = new Myobject();
ThreadA threadA = new ThreadA(myobject);
threadA.setName("a");ThreadB threadB  =new ThreadB(myobject);
threadB.setName("b");
threadA.start();
threadB.start();
}}

1.5结果如下：

更改MyObject类后：

package edu.ymm.about_thread4;public class Myobject {synchronized public void methodA() {
try {
System.out.println("begin methodA threadName="
+ Thread.currentThread().getName());
Thread.sleep(5000);
System.out.println("end");
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}

其他三个类不变，结果如下：

通过上面的代码得到结论，调用关键字synchronized声明的方法一定是排队运行的。另外需要牢牢记住“共享”，因为只有共享资源的读写访问才需要同步化，如果不是共享资源，那么根本就没有同步的必要！

 下面我们来看另一种情况：

（2）、其他方法被调用的效果，以及查看Lock锁对象的效果：

2.1继续创建一个MyObject类：

package edu.ymm.about_thread4;public class Myobject {synchronized public void methodA() {
try {
System.out.println("begin methodA threadName="
+ Thread.currentThread().getName());
Thread.sleep(5000);
System.out.println("end endTime" + System.currentTimeMillis());
}catch (InterruptedException e) {
e.printStackTrace();
}
}
public void methodB() {
try {
System.out.println("begin methodB threadName="
+ Thread.currentThread().getName()
+ " begin Time" + System.currentTimeMillis());
Thread.sleep(5000);
System.out.println("end");
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}

2.2继续创建一个ThreadA类：

package edu.ymm.about_thread4;public class ThreadA extends Thread {private Myobject myobject;
public ThreadA(Myobject myobject) {
super();
this.myobject = myobject;
}@Override
public void run() {
super.run();
myobject.methodA();
}}

2.3继续创建一个ThreadB类：

package edu.ymm.about_thread4;public class ThreadB extends Thread {private Myobject myobject;
public ThreadB(Myobject myobject) {
super();
this.myobject = myobject;
}@Override
public void run() {
super.run();
myobject.methodB();
}}

2.4继续创建一个Test类：

package edu.ymm.about_thread4;public class Test {public static void main(String[] args) {Myobject myobject = new Myobject();
ThreadA threadA = new ThreadA(myobject);
threadA.setName("a");ThreadB threadB  =new ThreadB(myobject);
threadB.setName("b");
threadA.start();
threadB.start();
}}

结果如下：

通过这个例子我们可以得到的结论是：

（1）A线程先持有Object对象的Lock锁，B线程可以以异步的方式调用Object对象中的非synchronized类型的方法。

（2）A线程先持有Object对象的Lock锁，B线程如果在这时调用Object对象中的synchronized类型的方法则需要等待，也就是同步！

 2.脏读

　　在上面1的例子中已经实现多个线程调用同一个方法时，为了避免数据出现交叉的情况，使用synchronized关键字来进行同步。虽然在赋值时进行了同步。但是在取值时有可能出现一些意料不到的意外，这种情况就是脏读。发生脏读的情况是在读取实例变量时，此值已经被其他线程更改过了。

（1）创建一个publicVar类：

package edu.ymm.about_thread5;public class PublicVar {
public String username = "A";
public String password = "AA";
synchronized public void setValue(String username,String password) {
try {
this.username = username;
Thread.sleep(5000);
this.password = password;
System.out.println("setValue method thread name="
+ Thread.currentThread().getName()+ " username "
+ username + " password " + password);
}catch (InterruptedException e){
e.printStackTrace();
}
}
public void getValue() {
System.out.println("getValue method thread name="
+ Thread.currentThread().getName()+ " username "
+ username + " password " + password);
}
}

（2）创建一个ThreadA类：

package edu.ymm.about_thread5;public class ThreadA extends Thread {private PublicVar publicVar;
public ThreadA(PublicVar publicVar) {
super();
this.publicVar = publicVar;
}@Override
public void run() {
super.run();
publicVar.setValue("B", "BB");
}}

（3）创建一个Test类：

package edu.ymm.about_thread5;public class Test {public static void main(String[] args) {
try {
PublicVar publicVar = new PublicVar();
ThreadA threadA = new ThreadA(publicVar);
threadA.start();
Thread.sleep(2000);
publicVar.getValue();
}catch (InterruptedException e) {
e.printStackTrace();
}
}}

执行结果如下：

上述的结果中已经出现了脏读，username为B的密码成了“AA”。原因就是public void getValue()方法不是同步的，所以在任何时候都可以调用。解决办法就是加synchronized：

package edu.ymm.about_thread5;public class PublicVar {
public String username = "A";
public String password = "AA";
synchronized public void setValue(String username,String password) {
try {
this.username = username;
Thread.sleep(5000);
this.password = password;
System.out.println("setValue method thread name="
+ Thread.currentThread().getName()+ " username "
+ username + " password " + password);
}catch (InterruptedException e){
e.printStackTrace();
}
}
synchronized public void getValue() {
System.out.println("getValue method thread name="
+ Thread.currentThread().getName()+ " username "
+ username + " password " + password);
}
}

改后结果为：

可见，方法setValue()和方法getValue()被依次执行。通过这个例子不仅要知道脏读是通过synchronized解决的。还得明白以下几点：

　　当A线程调用anyObject对象加入synchronized 关键字的X方法时，A线程就获得了x方法锁，更准确地讲，是获得了对象的锁，所以其他线程必须等A线程执行完毕才可以调用x方法，但B线程可以随意调用其他的非synchronized同步方法。

　　当A线程调用anyobject对象加入synchronized关键字的X方法时，A线程就获得了X方法所在对象的锁，所以其他线程必须等A线程执行完毕才可以调用X方法，而B线程如果调用声明了synchronized关键字的非X方法时，必须等A线程将X方法执行完，也就是释放对象锁后才可以调用。这时A线程已经执行了一个完整的任务，也就是说usemame和password这两个实例变量已经同时被赋值，不存在脏读的基本环境。

　　脏读一定会出现操作实例变量的情况下，这就是不同线程 “争抢”实例变量的结果。