java thread synchronized 理解-CSDN博客

Java Thread 用起来并不难，但往往还是容易出错。

我们知道 synchronized 关键字主要是防止多线程访问共享资源。

下面是个简单的测试，关于synchronized 使用。

view plaincopy to clipboardprint?
/**
* @author gaofeng
* @date 2009-12-18
*/
public class SynDemo {

    public SynDemo() {
    }

    public static void main(String[] args) {

        final Message message = new Message();
        Thread t1 = new Thread() {
            @Override
            public void run() {
                message.printA();
            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
                message.printA();
            }
        };

        t1.start();
        t2.start();
    }
}

class Message {

    private int value = 1;
    public void printA() {
        while (true) {
            try {
                 Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out
                    .println("" + Thread.currentThread() + " valueA:" + value);
        }
    }
}
/**
* @author gaofeng
* @date 2009-12-18
*/
public class SynDemo {

public SynDemo() {
}

public static void main(String[] args) {

  final Message message = new Message();
  Thread t1 = new Thread() {
   @Override
   public void run() {
    message.printA();
   }
  };

  Thread t2 = new Thread() {
   @Override
   public void run() {
    message.printA();
   }
  };

t1.start();
t2.start();
}
}

class Message {

private int value = 1;
public void printA() {
  while (true) {
   try {
        Thread.sleep(1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out
     .println("" + Thread.currentThread() + " valueA:" + value);
  }
}
}

2个线程访问printA方法，这个打印结果是：

Thread[Thread-0,5,main] valueA:1
Thread[Thread-1,5,main] valueA:1
Thread[Thread-0,5,main] valueA:1
Thread[Thread-1,5,main] valueA:1
Thread[Thread-1,5,main] valueA:1
Thread[Thread-0,5,main] valueA:1

在printA方法上增加 synchronized 打印结果;

Thread[Thread-0,5,main] valueA:1
Thread[Thread-0,5,main] valueA:1
Thread[Thread-0,5,main] valueA:1
Thread[Thread-0,5,main] valueA:1
Thread[Thread-0,5,main] valueA:1

同时只能是一个线程访问printA方法.

下面在Message类中添加一个 printB方法,并且加上synchronized 关键字.

public synchronized void printB() {
while (true) {
   try {
    Thread.sleep(1000);
   } catch (Exception e) {
    e.printStackTrace();
   }
System.out.println("" + Thread.currentThread() + " valueB:" + value);
}
}

2个线程分别访问 printA 和 printB 方法.

如果不测试，我的理解是 printA 和 printB 都能交替打印结果，因为2个线程访问不同的方法，尽管有synchronized 关键字 ,实际并非.

Thread[Thread-0,5,main] valueA:1
Thread[Thread-0,5,main] valueA:1
Thread[Thread-0,5,main] valueA:1
Thread[Thread-0,5,main] valueA:1

打印的结果任然只有一个线程访问。

主要的原因是 synchronized 关键字并非只锁定当前修饰的方法，它其实锁定了整个class中synchronized 修饰过的方法。

只要是其它线程访问到synchronized 修饰的方法和代码块，都不能被访问。

但如果是在printA上加个static 结果是怎样，测试的结果是交替打印，在把printB上加上static后, 此时只能有一个方法能执行。

因此，synchronized 是锁定同种类的方法，如果加了static修饰，只锁定所有static的方法。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/birdsaction/archive/2009/12/18/5031707.aspx