synchronized关键字的作用（一）

synchronized的作用（一）

synchronized的作用
一、同步方法
public synchronized void methodAAA(){

//….

}
锁定的是调用这个同步方法的对象

测试：
a、不使用这个关键字修饰方法，两个线程调用同一个对象的这个方法。
目标类：

public class TestThread {
    public  void execute(){  //synchronized,未修饰
        for(int i=0;i<100;i++){
              System.out.println(i);
          }
      }
}

public class TestThread {
public  void execute(){  //synchronized,未修饰
for(int i=0;i<100;i++){
System.out.println(i);
}
}
}

线程类：

public class ThreadA implements Runnable{
      TestThread test=null;
    public ThreadA(TestThread pTest){  //对象有外部引入，这样保证是同一个对象
          test=pTest;
      }
    public void run() {
          test.execute();
      }
}

public class ThreadA implements Runnable{
TestThread test=null;
public ThreadA(TestThread pTest){  //对象有外部引入，这样保证是同一个对象
test=pTest;
}
public void run() {
test.execute();
}
}

调用：

TestThread test=new TestThread();
Runnable runabble=new ThreadA(test);
Thread a=new Thread(runabble,"A");
a.start();
Thread b=new Thread(runabble,"B");
b.start();

TestThread test=new TestThread();
Runnable runabble=new ThreadA(test);
Thread a=new Thread(runabble,"A");
a.start();
Thread b=new Thread(runabble,"B");
b.start();

结果：
输出的数字交错在一起。说明不是同步的，两个方法在不同的线程中是异步调用的。

b、修改目标类，增加synchronized修饰

public class TestThread {
    public synchronized  void execute(){  //synchronized修饰
        for(int i=0;i<100;i++){
              System.out.println(i);
          }
      }
}

public class TestThread {
public synchronized  void execute(){  //synchronized修饰
for(int i=0;i<100;i++){
System.out.println(i);
}
}
}

结果：
输出的数字是有序的，首先输出A的数字，然后是B，说明是同步的，虽然是不同的线程，但两个方法是同步调用的。
注意：上面虽然是两个不同的线程，但是是同一个实例对象。下面使用不同的实例对象进行测试。

c、每个线程都有独立的TestThread对象。
目标类：

public class TestThread {
    public synchronized void execute(){  //synchronized修饰
        for(int i=0;i<100;i++){
              System.out.println(i);
          }
      }
}

public class TestThread {
public synchronized void execute(){  //synchronized修饰
for(int i=0;i<100;i++){
System.out.println(i);
}
}
}

线程类：

public class ThreadA implements Runnable{
    public void run() {
          TestThread test=new TestThread();
          test.execute();
      }
}

public class ThreadA implements Runnable{
public void run() {
TestThread test=new TestThread();
test.execute();
}
}

调用：

Runnable runabble=new ThreadA();
Thread a=new Thread(runabble,"A");
a.start();
Thread b=new Thread(runabble,"B");
b.start();

Runnable runabble=new ThreadA();
Thread a=new Thread(runabble,"A");
a.start();
Thread b=new Thread(runabble,"B");
b.start();

结果：
输出的数字交错在一起。说明虽然增加了synchronized 关键字来修饰方法，但是不同的线程调用各自的对象实例，两个方法仍然是异步的。