同一个类中的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