java多线程-synchronized

synchronized是Java中使用的最基本的一个同步方法，使用 synchronized关键字来控制并发访问方法。只有一个执行线程将会访问一个对象中被synchronized关键字声明的方法。如果另一个线程试图访问同一个对象中任何被synchronized关键字声明的方法，它将被暂停，直到第一个线程结束方法的执行。

每个方法声明为synchronized关键字是一个临界区，Java只允许一个对象执行其中的一个临界区。

静态方法有不同的行为。只有一个执行线程访问被synchronized关键字声明的静态方法，但另一个线程可以访问该类的一个对象中的其他非静态的方法。 你必须非常小心这一点，因为两个线程可以访问两个不同的同步方法，如果其中一个是静态的而另一个不是。如果这两种方法改变相同的数据,你将会有数据不一致 的错误。

同一个类中有多个synchronized关键字声明的静态方法。只要有一个线程访问了其中一个，其它线程则不可以访问任务一个synchronized关键字声明的静态方法，但可以访问该类其它同步方法和普通方法。

示例：

import java.util.Scanner;

public class SynchronizedTest {

public static synchronized void test1(){
System.out.println(Thread.currentThread().getName()+"进入阻塞！任意键结束！");
Scanner a = new Scanner(System.in);
a.next();

}

public static synchronized void test2(){
System.out.println(Thread.currentThread().getName()+"进入阻塞！任意键结束！");
Scanner a = new Scanner(System.in);
a.next();
}

public synchronized void test3(){
System.out.println(Thread.currentThread().getName()+"开始运行！");
System.out.println(Thread.currentThread().getName()+"请稍等...");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"运行结束！");
}

public void test4(){
System.out.println(Thread.currentThread().getName()+"没有阻塞，运行结束！");
}

public static void main(String[] args) {
Thread a = new Thread(new Runnable(){
@Override
public void run() {
SynchronizedTest.test1();
}
});

Thread b = new Thread(new Runnable(){
@Override
public void run() {
SynchronizedTest.test2();
}
});

Thread c = new Thread(new Runnable(){
@Override
public void run() {
new SynchronizedTest().test3();
}
});

Thread d = new Thread(new Runnable(){
@Override
public void run() {
new SynchronizedTest().test3();;
}
});

Thread e = new Thread(new Runnable(){
@Override
public void run() {
new SynchronizedTest().test4();;
}
});

final SynchronizedTest syn = new SynchronizedTest();
Thread f = new Thread(new Runnable(){
@Override
public void run() {
syn.test3();;
}
});

Thread g = new Thread(new Runnable(){
@Override
public void run() {
syn.test3();;
}
});

a.setName("线程1");
b.setName("线程2");
c.setName("线程3(与线程4不同对象的同一任务)");
d.setName("线程4(与线程3不同对象的同一任务)");
e.setName("线程5");
f.setName("线程6(与线程7同对象的同一任务)");
g.setName("线程7(与线程6同对象的同一任务)");

a.start();
b.start();
c.start();
d.start();
e.start();
f.start();
g.start();

}
}

结果：

线程1进入阻塞！任意键结束！
线程4(与线程3不同对象的同一任务)开始运行！
线程4(与线程3不同对象的同一任务)请稍等...
线程6(与线程7同对象的同一任务)开始运行！
线程6(与线程7同对象的同一任务)请稍等...
线程3(与线程4不同对象的同一任务)开始运行！
线程3(与线程4不同对象的同一任务)请稍等...
线程5没有阻塞，运行结束！
线程4(与线程3不同对象的同一任务)运行结束！
线程6(与线程7同对象的同一任务)运行结束！
线程3(与线程4不同对象的同一任务)运行结束！
线程7(与线程6同对象的同一任务)开始运行！
线程7(与线程6同对象的同一任务)请稍等...
线程7(与线程6同对象的同一任务)运行结束！
d
线程2进入阻塞！任意键结束！
d

可以看到：

线程6与线程7 排队执行

线程3与线程6 没有排队

线程1与线程2 排队执行

线程1阻塞时，其它非静态方法都能顺利执行