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，是不被同步的。