java并发编程学习之synchronized学习总结

一、修饰方法
当synchronized用来修饰方法的时候，实际上取得的锁是当前对象的方法锁，也就是说，这个方法还可以被其他线程的该类对象进行访问。直接用代码测试：

package org.netease.concurrent;

public class Thread2 {

    void start() {
        A a = new A();
        B b = new B();
        C c = new C();
        a.start();
        b.start();
        c.start();
    }

    class A extends Thread {
        public void run() {
            print("a");
        }
    }

    class B extends Thread {
        public void run() {
            print("b");
        }
    }

    class C extends Thread {
        public void run() {
            print("c");
        }
    }

    public synchronized  void print(String a) {
        System.out.println("----print----" + a);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("----print2----" + a);
    }

    public static void main(String[] args) {
        new Thread2().start();

    }
}

打印的结果是：
—-print—-a
—-print2—-a
—-print—-c
—-print2—-c
—-print—-b
—-print2—-b
当然这个结果不是唯一的，这里只是为了测试synchronized对方法的加锁，没有进行线程执行顺序控制。
结果分析：从这个结果看，因为我是通过new了一个Thread2对象进行调用方法启动的三个线程，这个三个线程是用的同一个对象，所以用synchronized加在了方法上，已经实现了对这个方法并发访问控制，下面再来测试一下多个对象访问

代码2：

package org.netease.concurrent;

public class Thread2 {

    void start() {
        A a = new A();
        B b = new B();
        C c = new C();
        a.start();
        b.start();
        c.start();
    }
    void start2() {
        A a = new A();
        B b = new B();
        C c = new C();
        a.start();
        b.start();
        c.start();
    }

    class A extends Thread {
        public void run() {
            print("a");
        }
    }

    class B extends Thread {
        public void run() {
            print("b");
        }
    }

    class C extends Thread {
        public void run() {
            print("c");
        }
    }

    public synchronized  void print(String a) {
        System.out.println("----print----" + a);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("----print2----" + a);
    }

    public static void main(String[] args) {
        new Thread2().start();
        new Thread2().start2();

    }
}

新增了一个对象同样启动了三个线程，去访问的时候，发现打印的结果如下：
—-print—-c
—-print—-a
//这里有休眠延迟
—-print2—-a
—-print2—-c
—-print—-b
—-print—-a
—-print2—-a
—-print2—-b
—-print—-b
—-print—-c
—-print2—-b
—-print2—-c

这个print c和print a 是同时打印出来的，这就说明synchronized方法，只是当前的对象锁。
思考：spring中的controller service等默认都是单例的，也就是只有一个对象，如果在方法上加了synchronized关键字，即可实现了该方法的并发控制，只是学习使用，实际上并不可行，不然要是一万个请求过来了，那慢慢等吧。。哈哈，估计全部都是TimeOutException
继续探索synchronized 。。。前进。。。前进。。。
PS：2015-12-21 21:12:23 加上：synchronized不具有继承性，意思是：父类的synchronized方法，如果子类没有继续加上synchronized，是不被同步的。