一 修饰方法
Synchronized修饰一个方法很简单,就是在方法的前面加synchronized,synchronized修饰方法和修饰一个代码块类似,只是作用范围不一样,修饰代码块是大括号括起来的范围,而修饰方法范围是整个函数。
Ex:
一、
public synchronized void method()
{
// todo
}
二、
- public void method()
- {
- synchronized(this) {
- // todo
- }
- }
写法一修饰的是一个方法,写法二修饰的是一个代码块,但写法一与写法二是等价的,都是锁定了整个方法时的内容。
synchronized关键字不能继承。
虽然可以使用synchronized来定义方法,但synchronized并不属于方法定义的一部分,因此,synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字,而在子类中覆盖了这个方法,在子类中的这个方法默认情况下并不是同步的,而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然,还可以在子类方法中调用父类中相应的方法,这样虽然子类中的方法不是同步的,但子类调用了父类的同步方法,因此,子类的方法也就相当于同步了。这两种方式的例子代码如下:
在子类方法中加上synchronized关键字
class Parent {
public synchronized void method() { }
}
class Child extends Parent {
public synchronized void method() { }
}
在子类方法中调用父类的同步方法
- class Parent {
- public synchronized void method() { }
- }
- class Child extends Parent {
- public void method() { super.method(); }
- }
- 在定义接口方法时不能使用synchronized关键字。
- 构造方法不能使用synchronized关键字,但可以使用synchronized代码块来进行同步。
二 修饰一个代码块
1)一个线程访问一个对象中的synchronized(this)同步代码块时,其他试图访问该对象的线程将被阻塞
注意下面两个程序的区别
- class SyncThread implements Runnable {
- private static int count;
- public SyncThread() {
- count = 0;
- }
- public void run() {
- synchronized(this) {
- for (int i = 0; i < 5; i++) {
- try {
- System.out.println(Thread.currentThread().getName() + ":" + (count++));
- Thread.sleep(100);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- }
- public int getCount() {
- return count;
- }
- }
- public class Demo00 {
- public static void main(String args[]){
- //test01
- // SyncThread s1 = new SyncThread();
- // SyncThread s2 = new SyncThread();
- // Thread t1 = new Thread(s1);
- // Thread t2 = new Thread(s2);
- //test02
- SyncThread s = new SyncThread();
- Thread t1 = new Thread(s);
- Thread t2 = new Thread(s);
- t1.start();
- t2.start();
- }
- }
test1运行结果:
test2运行结果:
当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时,在同一时刻只能有一个线程得到执行,另一个线程受阻塞,必须等待当前线程执行完这个代码块以后才能执行该代码块。Thread1和thread2是互斥的,因为在执行synchronized代码块时会锁定当前的对象,只有执行完该代码块才能释放该对象锁,下一个线程才能执行并锁定该对象
为什么上面的例子中thread1和thread2同时在执行。这是因为synchronized只锁定对象,每个对象只有一个锁(lock)与之相关联。
2)当一个线程访问对象的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块
ex:
- class Counter implements Runnable{
- private int count;
- public Counter() {
- count = 0;
- }
- public void countAdd() {
- synchronized(this) {
- for (int i = 0; i < 5; i ++) {
- try {
- System.out.println(Thread.currentThread().getName() + ":" + (count++));
- Thread.sleep(100);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- }
- //非synchronized代码块,未对count进行读写操作,所以可以不用synchronized
- public void printCount() {
- for (int i = 0; i < 5; i ++) {
- try {
- System.out.println(Thread.currentThread().getName() + " count:" + count);
- Thread.sleep(100);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- public void run() {
- String threadName = Thread.currentThread().getName();
- if (threadName.equals("A")) {
- countAdd();
- } else if (threadName.equals("B")) {
- printCount();
- }
- }
- }
- public class Demo00{
- public static void main(String args[]){
- Counter counter = new Counter();
- Thread thread1 = new Thread(counter, "A");
- Thread thread2 = new Thread(counter, "B");
- thread1.start();
- thread2.start();
- }
- }
结果:
B count:0
A:0
B count:1
A:1
B count:2
A:2
B count:4
A:3
A:4
B count:5
可以看见B线程的调用是非synchronized,并不影响A线程对synchronized部分的调用。从上面的结果中可以看出一个线程访问一个对象的synchronized代码块时,别的线程可以访问该对象的非synchronized代码块而不受阻塞。
3)指定要给某个对象加锁
- /**
- * 银行账户类
- */
- class Account {
- String name;
- float amount;
- public Account(String name, float amount) {
- this.name = name;
- this.amount = amount;
- }
- //存钱
- public void deposit(float amt) {
- amount += amt;
- try {
- Thread.sleep(100);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- //取钱
- public void withdraw(float amt) {
- amount -= amt;
- try {
- Thread.sleep(100);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- public float getBalance() {
- return amount;
- }
- }
- /**
- * 账户操作类
- */
- class AccountOperator implements Runnable{
- private Account account;
- public AccountOperator(Account account) {
- this.account = account;
- }
- public void run() {
- synchronized (account) {
- account.deposit(500);
- account.withdraw(500);
- System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
- }
- }
- }
- public class Demo00{
- //public static final Object signal = new Object(); // 线程间通信变量
- //将account改为Demo00.signal也能实现线程同步
- public static void main(String args[]){
- Account account = new Account("zhang san", 10000.0f);
- AccountOperator accountOperator = new AccountOperator(account);
- final int THREAD_NUM = 5;
- Thread threads[] = new Thread[THREAD_NUM];
- for (int i = 0; i < THREAD_NUM; i ++) {
- threads[i] = new Thread(accountOperator, "Thread" + i);
- threads[i].start();
- }
- }
- }
结果:
Thread0:10000.0
Thread4:10000.0
Thread3:10000.0
Thread2:10000.0
Thread1:10000.0
在AccountOperator 类中的run方法里,我们用synchronized 给account对象加了锁。这时,当一个线程访问account对象时,其他试图访问account对象的线程将会阻塞,直到该线程访问account对象结束。也就是说谁拿到那个锁谁就可以运行它所控制的那段代码。
当有一个明确的对象作为锁时,就可以用类似下面这样的方式写程序。
public void method3(SomeObject obj)
{
//obj 锁定的对象
synchronized(obj)
{
// todo
}
}
当没有明确的对象作为锁,只是想让一段代码同步时,可以创建一个特殊的对象来充当锁:
- class Test implements Runnable
- {
- private byte[] lock = new byte[0]; // 特殊的instance变量
- public void method()
- {
- synchronized(lock) {
- // todo 同步代码块
- }
- }
- public void run() {
- }
- }
三 修饰一个静态的方法
Synchronized也可修饰一个静态方法,用法如下:
- public synchronized static void method() {
- // todo
- }
- 静态方法是属于类的而不属于对象的。同样的,synchronized修饰的静态方法锁定的是这个类的所有对象。
- /**
- * 同步线程
- */
- class SyncThread implements Runnable {
- private static int count;
- public SyncThread() {
- count = 0;
- }
- public synchronized static void method() {
- for (int i = 0; i < 5; i ++) {
- try {
- System.out.println(Thread.currentThread().getName() + ":" + (count++));
- Thread.sleep(100);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- public synchronized void run() {
- method();
- }
- }
- public class Demo00{
- public static void main(String args[]){
- SyncThread syncThread1 = new SyncThread();
- SyncThread syncThread2 = new SyncThread();
- Thread thread1 = new Thread(syncThread1, "SyncThread1");
- Thread thread2 = new Thread(syncThread2, "SyncThread2");
- thread1.start();
- thread2.start();
- }
- }
结果:
SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9
syncThread1和syncThread2是SyncThread的两个对象,但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法method,而静态方法是属于类的,所以syncThread1和syncThread2相当于用了同一把锁。
四 修饰一个类
本例的的给class加锁和上例的给静态方法加锁是一样的,所有对象公用一把锁
Synchronized还可作用于一个类,用法如下:
- class ClassName {
- public void method() {
- synchronized(ClassName.class) {
- // todo
- }
- }
- }
- /**
- * 同步线程
- */
- class SyncThread implements Runnable {
- private static int count;
- public SyncThread() {
- count = 0;
- }
- public static void method() {
- synchronized(SyncThread.class) {
- for (int i = 0; i < 5; i ++) {
- try {
- System.out.println(Thread.currentThread().getName() + ":" + (count++));
- Thread.sleep(100);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- }
- public synchronized void run() {
- method();
- }
- }
总结
A. 无论synchronized关键字加在方法上还是对象上,如果它作用的对象是非静态的,则它取得的锁是对象;如果synchronized作用的对象是一个静态方法或一个类,则它取得的锁是对类,该类所有的对象同一把锁。
B. 每个对象只有一个锁(lock)与之相关联,谁拿到这个锁谁就可以运行它所控制的那段代码。
C. 实现同步是要很大的系统开销作为代价的,甚至可能造成死锁,所以尽量避免无谓的同步控制。