【Java并发】synchronized锁住的内容

synchronized用在方法上锁住的是什么？

锁住的是当前对象的当前方法，会使得其他线程访问该对象的synchronized方法或者代码块阻塞，但并不会阻塞非synchronized方法。

synchronized(this)锁住的是什么？

锁住的是当前的对象。当synchronized块里的内容执行完之后，释放当前对象的锁。同一时刻若有多个线程访问这个对象，则会被阻塞。

synchronized(object)锁住的什么？

锁住的是object对象。当synchronized块里的内容执行完之后，释放object对象的锁。同一时刻若有多个线程访问这个对象，则会被阻塞。

这里需要注意的是如果object为Integer、String等等包装类时（new出的对象除外），并不会锁住当前对象，也不会阻塞线程。因为包装类是final的，不可修改的，如果修改则会生成一个新的对象。所以，在一个线程对其进行修改后，其他线程在获取该对象的锁时，该对象已经不是原来的那个对象，所以获取到的是另一个对象的锁，所以不会产生阻塞。

例子：

public class Test7 {
    public static void main(String[] args) throws InterruptedException {
        Stu stu1 = new Stu(1);
        Thread t1 = new Thread(new MyThread(stu1));
        Thread t2 = new Thread(new MyThread(stu1));
        t1.start();
        t2.start();
    }
}

class MyThread implements Runnable{
    public MyThread(Stu stu){
        this.stu = stu;
    }
    private Stu stu;
    @Override
    public void run() {
        try {
            stu.a();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Stu{
    private Integer count ;
    public  Integer getCount(){
        return this.count;
    }
    public Stu(Integer count){
        this.count = count;
    }
    public  void a() throws InterruptedException {
        synchronized(count) {
            System.out.println(Thread.currentThread().getName()+"进入");
            count++;
            for (int i=0;i<3;i++){
                Thread.sleep(500);
                System.out.println(Thread.currentThread().getName()+"修改count");
            }
        }
    }
}

上边的代码中，开启了两个线程，分别对count进行++操作。虽然传入的都是实例stu1，两个线程中的count也是同一个对象，指向同一个实例。但是在一个线程对count进行++操作后，count不在是原来的count，而是一个新的Integer对象，这时第二个线程在访问count时，获取到的并不是原来的count的锁，而是新生成的Integer实例，这个实例并没有线程获取它的锁，因此第二个线程不会等待第一个线程执行完毕后再执行，而是交替执行。

输出结果如下：

当把

Stu stu1 = new Stu(1);

改为：

Stu stu1 = new Stu(new Integer(1));

时，输出如下：

因为new Integer(1)是一个对象，不会自动拆箱，所以，会按照先后顺序阻塞到第一个线程完毕后，第二个线程才开始执行。