Java Synchronized相关

快来打我* 2022-05-24 14:15 86阅读 0赞

（转自：[https://yq.aliyun.com/articles/24226 ][https_yq.aliyun.com_articles_24226] 侵删）

摘要： synchronized的说明 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

# synchronized的说明 #

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用.

# synchronized与static synchronized区别 #

## 说明 ##

synchronized是对类的当前实例进行加锁，防止其他线程同时访问该类的该实例的所有synchronized块，注意这里是“类的当前实例”，类的两个不同实例就没有这种约束了。

那么static synchronized恰好就是要控制类的所有实例的访问了，static synchronized是限制线程同时访问jvm中该类的所有实例同时访问对应的代码块。

实际上，如果在类中某方法或某代码块中有 synchronized，那么在生成一个该类实例后，该类也就有一个监视块，监视线程并发访问改实例synchronized保护块。而static synchronized则是该类的所有实例公用一个监视块，这便是两个的区别了。

也就是synchronized相当于 this.synchronized，而static synchronized相当于Something.synchronized.

结论：

A: synchronized static是某个类的范围，synchronized static cSync\{\}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

B: synchronized 是某实例的范围，synchronized isSync()\{\}防止多个线程同时访问这个实例中的synchronized 方法。

## 例程 ##

例如下面函数，创建了20个线程，每个线程都对race进行100000次累加，加static和不加static的increase函数，将会得到不同的结果。

### 例程一 ###

对于不加static 参数的increase() 函数，如果在同一个实例中调用，将能得到预期的结果（最终输出的race都会等于200000）：

</pre>
    <pre>package chapter12;
    class TestStatic {
     public static volatile int race = 0;
     public synchronized void increase() {
     race ++ ;
     }
    }
    public class StaticTest {
     public static void main(String[] args) {
     final TestStatic test = new TestStatic();
     Thread[] threads = new Thread[20];
     for(int i=0 ; i<20 ;i++) {
     threads[i] = new Thread(new Runnable(){
     @Override
     public void run() {
     for(int j = 0 ; j<100000 ; j++) {
     test.increase();
     }
     }
     });
     threads[i].start();
     }
     while(Thread.activeCount()>1) {
     Thread.yield();
     }
     System.out.println(TestStatic.race);
     }
    }</pre>
    <pre>

### 例程二 ###

对于不加static 参数的increase() 函数，如果在多个实例中调用，将不能得到预期的结果（最终输出的race都会小于200000）：

package chapter12;
    class TestStatic {
        public static volatile int race = 0;
        public synchronized void increase() {
            race ++ ;
        }
    }
    public class StaticTest {
        public static void main(String[] args) {
            Thread[] threads = new Thread[20];
            for(int i=0 ; i<20 ;i++) {
                threads[i] = new Thread(new Runnable(){
                    TestStatic test = new TestStatic();
                    @Override
                    public void run() {
                        for(int j = 0 ; j<100000 ; j++) {
                            test.increase();
                        }
                    }
                });
                threads[i].start();
            }
            while(Thread.activeCount()>1) {
                Thread.yield();
            }
            System.out.println(TestStatic.race);
        }
    }

### 例程三 ###

对于加上了static 参数的increase() 函数，不管是在多个实例中、还是在同一个实例中被调用，将都能得到预期的结果（最终输出的race都会

package chapter12;
    class TestStatic {
        public static volatile int race = 0;
        public static synchronized void increase() {
            race ++ ;
        }
    }
    public class StaticTest {
        public static void main(String[] args) {
    //      final TestStatic test = new TestStatic();
            Thread[] threads = new Thread[20];
            for(int i=0 ; i<20 ;i++) {
                threads[i] = new Thread(new Runnable(){
                    TestStatic test = new TestStatic();
                    @Override
                    public void run() {
                        for(int j = 0 ; j<100000 ; j++) {
                            test.increase();
                        }
                    }
                });
                threads[i].start();
            }
            while(Thread.activeCount()>1) {
                Thread.yield();
            }
            System.out.println(TestStatic.race);
        }
    }

## 题目 ##

(一个日本作者-结成浩的《java多线程设计模式》有这样的一个列子：

pulbic class Something()\{

public synchronized void isSyncA()\{\}

public synchronized void isSyncB()\{\}

public static synchronized void cSyncA()\{\}

public static synchronized void cSyncB()\{\}

那么，加入有Something类的两个实例a与b，那么下列组方法可以被1个以上线程同时访问呢

a.   x.isSyncA()与x.isSyncB()

b.   x.isSyncA()与y.isSyncA()

c.   x.cSyncA()与y.cSyncB()

d.   x.isSyncA()与Something.cSyncA()