同一個類中的2個方法都加了同步鎖，多個線程能同時訪問同一個類中的這兩個方法嗎？

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 同一個類中的2個方法都加了同步鎖，多個線程能同時訪問同一個類中的兩個方法嗎？
 * 這個問題需要考慮到Lock與synchronized兩種實現鎖的不同情形。因為這種情況
 * 下使用Lock和synchronized會有截然不同的結果。Lock獲取鎖，之后需要釋放鎖。
 * 如下代碼，多個線程不可訪問同一個類中的2個加了Lock鎖的方法
 */
public class SimultaneousThread {
    private int count = 0;
    //設置Lock鎖               重入鎖
    private Lock lock = new ReentrantLock();
    //方法1
    public Runnable run1 = new Runnable() {
        public void run() {
            //加鎖
            lock.lock();
            while (count < 1000) {
                try {
                    //打印是否執行該方法
                    System.out.println(Thread.currentThread().getName() + "run1:" + count++);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            lock.unlock();
        }
    };
    //方法2
    public Runnable run2 = new Runnable() {
        public void run() {
            lock.lock();
            while(count<1000){
                try {
                    System.out.println(Thread.currentThread().getName()+"run2"+count++);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            lock.unlock();
        }
    };

    public static void main(String[] args) {
        //創建一個對象
        SimultaneousThread s = new SimultaneousThread();
        //獲取該對象的方法1
        new Thread(s.run1).start();
        //獲取該對象的方法2
        new Thread(s.run2).start();
    }
}

運行結果如下：

Thread-0run1:0
Thread-0run1:1
Thread-0run1:2
Thread-0run1:3
Thread-0run1:4
Thread-0run1:5
Thread-0run1:6
Thread-0run1:7
Thread-0run1:8
Thread-0run1:9
Thread-0run1:10
Thread-0run1:11

　　而synchronized卻不行，使用synchronized時，當我們訪問同一個類對象的時候，是同一把鎖，所以可以訪問該對象的其他synchronized方法。代碼如下：

　　

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 同一個類中的2個方法都加了同步鎖，多個線程能同時訪問同一個類中的兩個方法嗎？
 * 這個問題需要考慮到Lock與synchronized兩種實現鎖的不同情形。因為這種情況
 * 下使用Lock和synchronized會有截然不同的結果。Lock獲取鎖，之后需要釋放鎖。
 * 如下代碼，多個線程不可訪問同一個類中的2個加了Lock鎖的方法
 */
public class SimultaneousThread {
    private int count = 0;
    //設置Lock鎖               重入鎖
    private Lock lock = new ReentrantLock();
    //方法1
    public Runnable run1 = new Runnable() {
        public void run() {
            synchronized (this) {//設置關鍵字synchronized，以當前類為鎖
                while (count < 1000) {
                    try {
                        //打印是否執行該方法
                        System.out.println(Thread.currentThread().getName() + "run1" + count++);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    };
    //方法2
    public Runnable run2 = new Runnable() {
        public void run() {
            synchronized (this) {//設置關鍵字synchronized，以當前類為鎖
                while (count < 1000) {
                    try {
                        //打印是否執行該方法
                        System.out.println(Thread.currentThread().getName() + "run2" + count++);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    };

    public static void main(String[] args) {
        //創建一個對象
        SimultaneousThread s = new SimultaneousThread();
        //獲取該對象的方法1
        new Thread(s.run1).start();
        //獲取該對象的方法2
        new Thread(s.run2).start();
    }
}

運行結果如下：

Thread-0run10
Thread-1run21
Thread-0run12
Thread-1run23
Thread-0run14
Thread-1run25
Thread-0run16
Thread-0run18
Thread-0run19
Thread-0run110
Thread-0run111
Thread-0run112
Thread-0run113