多线程--对象锁和类锁

一.对象锁和类锁的区别

 对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

同步控制的范围越小，并发性能越好；反之，并发性能越差。一般来说，并发性能由高到底，synchronized 代码块>synchronized 同步方法>类锁。

二.对象锁

　　1.对象锁只针对同一个实例对象中synchronized 修饰的部分实现同步，对同一个类下的多个对象、同一个对象的非synchronized 修饰的部分不会阻塞 。

public class MyObject {
    //加对象锁
    public synchronized void method1(){
        System.out.println("method1 start----");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method1 end----");
    }

    //加对象锁
    public synchronized void method2(){
        System.out.println("method2 start----");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method2 end----");
    }

    //不加锁
    public  void method3(){
        System.out.println("method3 start----");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method3 end----");
    }
}

 多线程操作同一个对象synchronized 修饰的部分，一个线程必须等待前一个线程的对象锁释放之后才开始执行，线程执行顺序不确定，运行结果如下：

　　　　　//同一个实例对象
        final MyObject obj1=new MyObject();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj1.method1();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                obj1.method2();
            }
        }).start();

多线程操作不同对象，对象锁无效，运行结果如下：

        //不同实例对象
        final MyObject obj1=new MyObject();
        final MyObject obj2=new MyObject();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj1.method1();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                obj2.method2();
            }
        }).start();    

多线程操作同一对象的同步方法和非同步方法，彼此之间互不影响，不会发生阻塞，运行结果如下：

        //同一对象
        final MyObject obj1=new MyObject();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj1.method1();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                obj1.method3();
            }
        }).start();
    }    

三.类锁

 类锁是锁住整个类，不管有多少个对象,共用一把类锁,且类锁只有一把,不管怎么调用,都会同步。

//加类锁
    public synchronized static void method4(){
        System.out.println(Thread.currentThread().getName()+" call method4 start----");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" call method4 end----");
    }

final MyObject obj1 = new MyObject();
        final MyObject obj2 = new MyObject();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj1.method4();
            }
        }, "thread1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                obj1.method4();
            }
        }, "thread2").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                obj2.method4();
            }
        }, "thread3").start();
    }