synchronized 方法与锁对象

两个线程均调用共享对象的同步方法：

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

class ThreadA extends Thread{
private MyObject object;

public ThreadA(MyObject object){
this.object = object;
}

@Override
public void run() {
object.methodA();
}
}

class ThreadB extends Thread{
private MyObject object;

public ThreadB(MyObject object){
this.object = object;
}

@Override
public void run() {
object.methodA();
}
}
public class Run {
public static void main(String[] args) {
MyObject object = new MyObject();
ThreadA a = new ThreadA(object);
a.setName("A");
ThreadB b = new ThreadB(object);
b.setName("B");
a.start();
b.start();
}
}

结果肯定是顺序执行：

begin methodA threadName= A
methodA end
begin methodA threadName= B
methodA end

A线程调用共享对象的同步方法，B线程调用共享对象非同步方法：

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

public void methodB(){
System.out.println("begin methodB threadName= " + Thread.currentThread().getName());
try {
Thread.sleep(5000);
System.out.println("methodB end");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

class ThreadA extends Thread{
private MyObject object;

public ThreadA(MyObject object){
this.object = object;
}

@Override
public void run() {
object.methodA();
}
}

class ThreadB extends Thread{
private MyObject object;

public ThreadB(MyObject object){
this.object = object;
}

@Override
public void run() {
object.methodB();
}
}
public class Run {
public static void main(String[] args) {
MyObject object = new MyObject();
ThreadA a = new ThreadA(object);
a.setName("A");
ThreadB b = new ThreadB(object);
b.setName("B");
a.start();
b.start();
}
}

结果是：

begin methodA threadName= A
begin methodB threadName= B
methodA end
methodB end

A线程调用共享对象的同步方法，B线程调用共享对象另一个同步方法

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

public synchronized void methodB(){
System.out.println("begin methodB threadName= " + Thread.currentThread().getName());
try {
Thread.sleep(5000);
System.out.println("methodB end");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

class ThreadA extends Thread{
private MyObject object;

public ThreadA(MyObject object){
this.object = object;
}

@Override
public void run() {
object.methodA();
}
}

class ThreadB extends Thread{
private MyObject object;

public ThreadB(MyObject object){
this.object = object;
}

@Override
public void run() {
object.methodB();
}
}
public class Run {
public static void main(String[] args) {
MyObject object = new MyObject();
ThreadA a = new ThreadA(object);
a.setName("A");
ThreadB b = new ThreadB(object);
b.setName("B");
a.start();
b.start();
}
}

结果是：

begin methodA threadName= A
methodA end
begin methodB threadName= B
methodB end

结论：

1. A线程和B线程均调用object对象的synchronized方法，则必须是同步方式调用

2. A线程先持有object对象的Lock锁，B线程可以以异步方式调用object对象中的非synchronized类型的方法

3. A线程先持有object对象的Lock锁，B线程如果此时调用object对象中的synchronized类型的方法则需等待，即只能是同步方式调用

结论2即对应了脏读的现象：

比如赋值方法是同步，取值方法是非同步，则可能出现脏读，即在读取实例变量时，此值已经被其他线程更改过了

class MyObject{
private String username = "A";
private String password = "AA";

public synchronized void setValue(String username, String password){
this.username = username;
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.password = password;
System.out.println("setValue username : " + username + " password : " + password);
}

public void getValue(){
System.out.println("getValue username : " + username + " password : " + password);
}
}

class ThreadA extends Thread{
private MyObject object;

public ThreadA(MyObject object){
this.object = object;
}

@Override
public void run() {
object.setValue("B", "BB");
}
}

public class Run {
public static void main(String[] args) {
MyObject object = new MyObject();
ThreadA a = new ThreadA(object);
a.setName("A");
a.start();
try {
Thread.sleep(200);//结果受此值影响
} catch (InterruptedException e) {
e.printStackTrace();
}
object.getValue();
}
}

可对getValue添加synchronzied关键字修饰，避免脏读

当线程调用anyObject对象加入synchronized关键字修饰的X方法时，A线程就获得了X方法锁，更准确的讲是获得了anyObject对象的锁，所以其他线程必须等A线程执行完毕才可以调用X方法，但是其他线程可以调用anyObject的其他非synchronized关键字修饰的方法。可若其他线程调用anyOjbect的其他synchronized关键字修饰的方法时，也必须等待A线程执行完毕，释放了对象锁后才可以调用