多线程synchronized和synchronized static方法的区别

synchronized static和synchronized 关键字

1.synchronized satic 方法，如果是一个方法加上static关键字和synchronized。static一定不属于任何对象，属于一个类。那么它锁的是当前类的对象的class对象。因为Java中无论一个类有多少个对象，这些对象会对应唯一一个Class对象,因为当前线程分别访问了同一个类的两个对象的static，synchronized方法时候。他们执行的顺序也是顺序的，也就是说一个线程先去执行方法，执行完毕后另一个线程开始。（非常重要）
2.synichronized关键字锁的是对象锁,

代码例子：

class Resource {
    public synchronized void method1() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method1 running...");
    }

    public synchronized void method2() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method2 running...");
    }

    public synchronized static void method3() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method3 running...");
    }

    public synchronized static void method4() {
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method4 running...");
    }
}

//线程1-调用 synchronized方法
class Method1Thread extends Thread {

    private Resource syncMethodTest;

    public Method1Thread(Resource syncMethodTest) {
        this.syncMethodTest = syncMethodTest;
    }

    @Override
    public void run() {
        syncMethodTest.method1();
    }
}

//线程2-调用 synchronized方法
class Method2Thread extends Thread {

    private Resource resource;

    public Method2Thread(Resource syncMethodTest) {
        this.resource = syncMethodTest;
    }

    @Override
    public void run() {
        resource.method2();
    }
}

//线程3-调用 synchronized static方法
class Method3Thread extends Thread {

    private Resource syncMethodTest;

    public Method3Thread(Resource syncMethodTest) {
        this.syncMethodTest = syncMethodTest;
    }

    @Override
    public void run() {
        syncMethodTest.method3();
    }
}

//线程4-调用 synchronized static方法
class Method4Thread extends Thread {

    private Resource syncMethodTest;

    public Method4Thread(Resource syncMethodTest) {
        this.syncMethodTest = syncMethodTest;
    }

    @Override
    public void run() {
        syncMethodTest.method4();
    }
}

测试类：

/**
 * Created by qianyi on 2017/9/9.
 */
public class StaticSynicTest {

    public static void main(String[] args) {
        Resource resource = new Resource();
        Resource resource1 = new Resource();
        //访问synchronized方法
        Thread t1 = new Method1Thread(resource);
        //访问synchronized方法
        Thread t2 = new Method2Thread(resource);
        //访问synchronized static方法
        Thread t3 = new Method3Thread(resource);
        //访问synchronized static方法        
        Thread t4 = new Method4Thread(resource);
        //访问synchronized static方法
        Thread t6 = new Method4Thread(resource1);
        //访问synchronized 方法
        Thread t5 = new Method2Thread(resource1);
        /**
         * 都是对同一个实例的synchronized域访问，因此不能被同时访问,
         */
        //        t1.start();
        //        t2.start();

        /**
         *是针对不同实例的，实例有两个,针对的不同的resource和resource1,因此可以同时被访问
         */
        //        t1.start();
        //        t5.start();

        /**
         *t1锁的是对象锁，t4锁的是Class锁。可以同时访问。
         */
//        t4.start();
//        t1.start();
        /**
         * t4和t6分别操作的资源不同，但是锁的是class锁，所以不可以同时访问
         */
//        t4.run();
//        t6.run();
    }
}

总结

1.synchronized 与static synchronized锁的范围不同,synchronized锁的是对象，static synchronized锁是class对象，两个互相不受影响。可以同时被访问。
2.synchronized static防止多个线程同时访问某一个方法。上面的例子是防止多个线程同时method3 和method4,即使操作资源的不同，因为锁的是Resource.class。class在真个内存中之后一个。所以多个线程不能同时访问。
3.synchronized锁的是对象。针对同一个实例（同一个对象）,一定是同一个实例，多个线程不能同时访问。如果是不同的实例，那么也可以同时访问，锁的是对象(Resrouce的实例,针对同一个实例的多个线程访问必须遵守顺序)。