类锁与实例锁

Synchronized（实例锁）和 static Synchronized（类锁）区别

　　实例锁：锁在某个对象上，如果该类是单例的，那么该锁也有全局锁的概念

　　类锁：该锁针对的类，无论实例多少个对象，那么线程都共享该锁。

 

Java的锁分为对象锁和类锁。

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

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

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

　　4. 同步加锁的是对象，而不是代码。因此，如果你的类中有一个同步方法，这个方法可以被两个不同的线程同时执行，只要每个线程自己创建一个的该类的实例即可。

　　5. 不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法。

　　6. synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法。

　　7.对一个全局对象或者类加锁时，对该类的所有对象都起作用。

 

 

对象锁：

当多个线程同属于一个对象时，线程是安全的

如：

public class ThreadTest implements Runnable {
    public synchronized void get() {
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getId());
        set();
    }

    private synchronized void set() {
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getId());
    }

    @Override
    public void run() {
        get();
    }

    public static void main(String[] args) {
        ThreadTest test = new ThreadTest();
        new Thread(test, "test").start();
        new Thread(test, "test").start();
        new Thread(test, "test").start();
    }
}

多次试验后的运行结果：

test:11
test:11
test:12
test:12
test:10
test:10

 

当多个线程不属于同一个对象时：

public class ThreadTest implements Runnable {
    public synchronized void get() {
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getId());
        set();
    }

    private synchronized void set() {
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getId());
    }

    @Override
    public void run() {
        get();
    }

    public static void main(String[] args) {
        ThreadTest test = new ThreadTest();
        ThreadTest test2 = new ThreadTest();
        new Thread(test, "test").start();
        new Thread(test, "test").start();
        new Thread(test, "test").start();
        new Thread(test2, "test2").start();
        new Thread(test2, "test2").start();
        new Thread(test2, "test2").start();
    }
}

结果：

test:10
test:10
test:12
test2:13
test:12
test2:13
test:11
test:11
test2:14
test2:14
test2:15
test2:15

 

可见，当对象1的线程在执行get方法时，还没执行完毕；对象2的线程也在执行get方法。

优化：

加入类锁 static synchronized之后：

代码：

public class ThreadTest implements Runnable {
    public static synchronized void get() {
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getId());
        set();
    }

    private static synchronized void set() {
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getId());
    }

    @Override
    public void run() {
        get();
    }

    public static void main(String[] args) {
        ThreadTest test = new ThreadTest();
        ThreadTest test2 = new ThreadTest();
        new Thread(test, "test").start();
        new Thread(test, "test").start();
        new Thread(test, "test").start();
        new Thread(test2, "test2").start();
        new Thread(test2, "test2").start();
        new Thread(test2, "test2").start();
    }
}

运行结果：

test:11
test:11
test2:13
test2:13
test:10
test:10
test2:14
test2:14
test:12
test:12
test2:15
test2:15

此时，同一个类的对象的所有线程在同一时刻只有一个线程执行get方法。

 

重入锁 ReentrantLock：

示例

public class ThreadTest2 implements Runnable {

    ReentrantLock lock = new ReentrantLock();

    public void get() {
        lock.lock();
        System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getId());
        set();
        lock.unlock();
    }

    public void set() {
        lock.lock();
        System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getId());
        lock.unlock();
    }

    @Override
    public void run() {
        get();
    }

    public static void main(String[] args) {
        ThreadTest2 test = new ThreadTest2();
        new Thread(test).start();
        new Thread(test).start();
        new Thread(test).start();
    }

}

多次运行结果：

Thread-0:10
Thread-0:10
Thread-1:11
Thread-1:11
Thread-2:12
Thread-2:12

多个线程不属于一个对象的情况下：

public class ThreadTest2 implements Runnable {

    ReentrantLock lock = new ReentrantLock();

    public void get() {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getId());
        set();
        lock.unlock();
    }

    public void set() {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getId());
        lock.unlock();
    }

    @Override
    public void run() {
        get();
    }

    public static void main(String[] args) {
        ThreadTest2 test = new ThreadTest2();
        ThreadTest2 test2 = new ThreadTest2();
        new Thread(test, "test").start();
        new Thread(test, "test").start();
        new Thread(test, "test").start();
        new Thread(test2, "test2").start();
        new Thread(test2, "test2").start();
        new Thread(test2, "test2").start();
    }

}

结果：

test:10
test2:14
test:10
test:11
test2:14
test:11
test2:13
test2:13
test:12
test:12
test2:15
test2:15

线程不安全的原因：多个对象都有自己的  ReentrantLock lock = new ReentrantLock();

因此不属于一个对象的多个线程之间用的不是同一把锁，解决方案，将ReentrantLock 对象声明为静态的，使其成为类变量。多个对象共享。

public class ThreadTest2 implements Runnable {

    static ReentrantLock lock = new ReentrantLock();

    public void get() {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getId());
        set();
        lock.unlock();
    }

    public void set() {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getId());
        lock.unlock();
    }

    @Override
    public void run() {
        get();
    }

    public static void main(String[] args) {
        ThreadTest2 test = new ThreadTest2();
        ThreadTest2 test2 = new ThreadTest2();
        new Thread(test, "test").start();
        new Thread(test, "test").start();
        new Thread(test, "test").start();
        new Thread(test2, "test2").start();
        new Thread(test2, "test2").start();
        new Thread(test2, "test2").start();
    }

}

 

 

END.