Java关键字synchronized

最新推荐文章于 2022-06-10 09:24:37 发布

ting说你跳

最新推荐文章于 2022-06-10 09:24:37 发布

阅读量415

点赞数 1

分类专栏： Java 文章标签： Java

本文链接：https://blog.csdn.net/sted_zxz/article/details/76862444

版权

Java 专栏收录该内容

32 篇文章 1 订阅

订阅专栏

引言

synchronized是Java中的关键字，Java中的每一个对象都可以作为锁。

1.对于同步方法块，锁是synchronized括号里配置的对象。
2.对于同步方法，锁是当前实例对象。
3.对于静态同步方法，锁是当前对象的Class对象。

修饰代码块

Demo1：

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;
   }
}

调用SyncThread：

SyncThread syncThread = new SyncThread();
Thread thread1 = new Thread(syncThread, "SyncThread1");
Thread thread2 = new Thread(syncThread, "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

当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。thread1和thread2是互斥的，因为在执行synchronized代码块时会锁定当前的对象syncThread，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。
我们再把SyncThread的调用稍微改一下：

Thread thread1 = new Thread(new SyncThread(), "SyncThread1");
Thread thread2 = new Thread(new SyncThread(), "SyncThread2");
thread1.start();
thread2.start();

结果如下：

SyncThread1:0 
SyncThread2:1 
SyncThread1:2 
SyncThread2:3 
SyncThread1:4 
SyncThread2:5 
SyncThread2:6 
SyncThread1:7 
SyncThread1:8 
SyncThread2:9

不是说一个线程执行synchronized代码块时其它的线程受阻塞吗？为什么上面的例子中thread1和thread2同时在执行。这是因为synchronized只锁定对象，每个对象只有一个锁（lock）与之相关联，而上面的代码等同于下面这段代码：

SyncThread syncThread1 = new SyncThread();
SyncThread syncThread2 = new SyncThread();
Thread thread1 = new Thread(syncThread1, "SyncThread1");
Thread thread2 = new Thread(syncThread2, "SyncThread2");
thread1.start();
thread2.start();

这时创建了两个SyncThread的对象syncThread1和syncThread2，线程thread1执行的是syncThread1对象中的synchronized的代码run，而线程thread2执行的是syncThread2对象中的synchronized的代码run；我们知道synchronized锁定的是对象，这时会有两把锁分别锁定syncThread1对象和syncThread2对象，而这两把锁是互不干扰的，不形成互斥，所以两个线程可以同时执行。

Demo2：

/**
 * 银行账户类
 */
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());
      }
   }
}

调用代码：

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();
}

结果如下：

Thread3:10000.0 
Thread2:10000.0 
Thread1:10000.0 
Thread4:10000.0 
Thread0:10000.0

在AccountOperator 类中的run方法里，我们用synchronized 给account对象加了锁。这时，当一个线程访问account对象时，其他试图访问account对象的线程将会阻塞，直到该线程访问account对象结束。也就是说谁拿到那个锁谁就可以运行它所控制的那段代码。

当如果没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的对象来充当锁，把AccountOperator 修改一下：

    private Account account;

    public AccountOperator(Account account) {
        this.account = account;
    }

    private byte[] lock = new byte[0];

    public void run() {
        synchronized (lock) {
            account.deposit(500);
            account.withdraw(500);
            System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
        }
    }

说明：零长度的byte数组对象创建起来将比任何对象都经济，查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

修饰非静态方法

synchronized修饰一个方法很简单，就是在方法的前面加synchronized：

    public synchronized void method() {
       // todo
    }

非静态方法锁定的就是当前类的实例对象，倘若一个类中有多个synchronized修饰的非静态方法，多个线程同时调用它们的时候，他们就会一个个被调用。可以查看线程安全类Vector的源码：

    public synchronized void addElement(E var1) {
        ++this.modCount;
        this.ensureCapacityHelper(this.elementCount + 1);
        this.elementData[this.elementCount++] = var1;
    }

    public synchronized boolean removeElement(Object var1) {
        ++this.modCount;
        int var2 = this.indexOf(var1);
        if(var2 >= 0) {
            this.removeElementAt(var2);
            return true;
        } else {
            return false;
        }
    }

    ……

修饰静态方法

我们知道静态方法是属于类的而不属于对象的，所以synchronized修饰的静态方法锁定的是这个类的.class对象。
Demo3：

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();
   }
}

调用代码：

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的两个不同的实例对象，但在syncThread1和syncThread2并发执行时却保持了线程同步。这是因为run中调用了被synchronized修饰的静态方法method，而静态方法是属于类的，所以syncThread1和syncThread2相当于用了同一把锁。

注意

静态同步方法的锁是类的.Class对象，非静态同步方法的锁是当前的实例对象，二者并不互斥。
Demo4：

class SayHello {
    public static synchronized void say88() {
        for (int i = 0; i < 8; i++) {
            System.out.println(i + "个" + "88");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void say99() {
        for (int i = 0; i < 8; i++) {
            System.out.println(i + "个" + "99");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SayHello sayHello = new SayHello();

        new Thread() {
            @Override
            public void run() {
                super.run();
                sayHello.say88();

            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                super.run();
                sayHello.say99();
            }
        }.start();
    }
}

调用结果：

0个88
0个99
1个88
1个99
2个88
2个99
3个88
3个99
4个88
4个99
5个88
5个99
6个88
6个99
7个88
7个99

显然二者没有关系，这一点有的博客上弄混淆了。

参考：Java中synchronized的用法

ting说你跳

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Java关键字synchronized

参考：Java中synchronized的用法引言synchronized是Java中的关键字，Java中的每一个对象都可以作为锁。1.对于同步方法块，锁是synchronized括号里配置的对象。 2.对于同步方法，锁是当前实例对象。 3.对于静态同步方法，锁是当前对象的Class对象。修饰代码块Demo1：class SyncThread implements Runnable {
复制链接

扫一扫