synchronized与static synchronized 的区别

线程的并发与并行
　　在单CPU系统中，系统调度在某一时刻只能让一个线程运行，虽然这种调试机 制有多种形式(大多数是时间片轮巡为主)，但无论如何，要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent)。而在多CPU系统 中，可以让两个以上的线程同时运行，这种可以同时让两个以上线程同时运行的方式叫做并行(parallel)。

　　在上面包括以后的所有论述中，请各位朋友谅解，我无法用最准确的词语来定义储如并发和并行这类术语，但我以我的经验能通俗地告诉大家它是怎么一回事，如果您看到我说的一些"标准"文档上说的不一样，只要意思一致，那您就不要挑刺了。

 

1.synchronized与static synchronized 的区别
      synchronized是对类的当前实例进行加锁，防止其他线程同时访问该类的该实例的所有synchronized块，注意这里是“类的当前实例”， 类的两个不同实例就没有这种约束了。那么static synchronized恰好就是要控制类的所有实例的访问了，static synchronized是限制线程同时访问jvm中该类的所有实例同时访问对应的代码快。实际上，在类中某方法或某代码块中有 synchronized，那么在生成一个该类实例后，改类也就有一个监视快，放置线程并发访问改实例synchronized保护快，而static synchronized则是所有该类的实例公用一个监视快了，也也就是两个的区别了,也就是synchronized相当于 this.synchronized，而
static synchronized相当于Something.synchronized.
      一个日本作者-结成浩的《java多线程设计模式》有这样的一个列子：
      pulbic class Something(){
         public synchronized void isSyncA(){}
         public synchronized void isSyncB(){}
         public static synchronized void cSyncA(){}
         public static synchronized void cSyncB(){}
     }
   那么，加入有Something类的两个实例a与b，那么下列组方法何以被1个以上线程同时访问呢
   a.   x.isSyncA()与x.isSyncB()
   b.   x.isSyncA()与y.isSyncA()
   c.   x.cSyncA()与y.cSyncB()
   d.   x.isSyncA()与Something.cSyncA()
    这里，很清楚的可以判断：
   a，都是对同一个实例的synchronized域访问，因此不能被同时访问
   b，是针对不同实例的，因此可以同时被访问
   c，因为是static synchronized，所以不同实例之间仍然会被限制,相当于Something.isSyncA()与   Something.isSyncB()了，因此不能被同时访问。
   那么，第d呢?，书上的 答案是可以被同时访问的，答案理由是synchronzied的是实例方法与synchronzied的类方法由于锁定（lock）不同的原因。
   个人分析也就是synchronized 与static synchronized 相当于两帮派，各自管各自，相互之间就无约束了，可以被同时访问。目前还不是分清楚java内部设计synchronzied是怎么样实现的。

    结论：A: synchronized static是某个类的范围，synchronized static cSync{}防止多个线程同时访问这个    类中的synchronized static 方法。它可以对类的所有对象实例起作用。
              B: synchronized 是某实例的范围，synchronized isSync(){}防止多个线程同时访问这个实例中的synchronized 方法。

 

2.synchronized方法与synchronized代码快的区别
      synchronized methods(){} 与synchronized（this）{}之间没有什么区别，只是 synchronized methods(){} 便于阅读理解，而synchronized（this）{}可以更精确的控制冲突限制访问区域，有时候表现更高效率。

 

3.synchronized关键字是不能继承的
     这个在http://www.learndiary.com/archives/diaries/2910.htm一文中看到的，我想这一点也是很值得注意的，继承时子类的覆盖方法必须显示定义成synchronized


源于一个想法：比如java中的一个方法
public static void method(){
    // ....code
}

是否在前面简单的加上synchronized 就可以实现同步了呢，java真的能帮我们实现吗？
/........................................./

加上synchronized ：

public synchronized  static void method(){
    // ....code
}
/........................................./

我总是不怎么相信，也不确定，这样简单的加上synchronized就能使多线程同步了。但下面的测试让我确定，确实，只要这么简单的做，java就可以实现多线程的同步了。下面看测试代码：

Java代码:
/**
 * 测试java多线程的同步，使用5个线程调用载体方法。
 * 
 * 测试用例1：给载体方法加上synchronized修饰词（如程序中）。
 * 结果：载体方法被同步，每秒打印一条记录；
 * 
 * 测试用例2：去掉载体方法的synchronized修饰词（请自己试下）。
 * 结果：载体方法没有被同步，5条记录很快打印完。
 * 
 * 结论：可想而知!给static方法添上synchronized修饰词，方法就被同步。
 * @author ayis
 *
 * Jan 13, 2009
 */ 
public class TestSynchronized { 
     
    public static void main(String args[]){ 
        // 开启5个线程调用载体方法 
        TestSynchronized.mutilThreadInvoke(5); 
    } 
     
    /**
     * 同步的载体方法
     */ 
    public synchronized static void method(){ 
        try { 
            Thread.sleep(1000); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } 
        System.out.println("method print. time:"+System.currentTimeMillis()); 
    } 
     
    /**
     * 多线程调用载体方法
     * @param n：调用线程的数目
     */ 
    public static void mutilThreadInvoke(int n){ 
        for(int i=0 ; i < n ; i++){ 
            new Thread( 
                    new Runnable(){ 
 
                        @Override 
                        public void run() { 
                            // 调用载体方法 
                            TestSynchronized.method(); 
                        } 
                         
                    } 
            ).start(); 
        } 
    } 
}

java线程同步示例代码:
class   A   {
        synchronized   void   f()   {
                //同步方法，执行时要获取到该对象的mornitor才do   something，如果对象mornitor已被其他线程获取，则等待直到其他线程放弃再锁定该对象
                //do   something;
        }
        void   g()   {

                //非同步方法，执行时也要获得该对象的mornitor才do   something，如果对象mornitor已被其他线程获取，则等待直到其他线程放弃再锁定
                synchronized   (this)   {
                        //do   something;
                }
        }
        //synchronized不要写错了！上边如果do   something完全一样的话，f和g等价，f其实是g的简写
}

 

       加在非static方法上的synchronized方法是和synchronized（this）块等价的，均为对象锁，即对this加锁。获得当前对象锁的线程，可以继续获得当前对象锁，JVM负责跟踪对象被加锁的次数。线程运行B方法，此时如果this锁可以用，线程获得该锁，线程给对象加 锁，计数器变成1，然后B方法调用A方法，由于是对同一个对象同一个线程，线程可以继续获得锁，计数器变为2，表示this被加锁2次。A方法完毕后，线 程释放锁，计数器变为1，此时对象锁对其他线程依然是不可获得的。B方法完毕后，线程继续释放锁，此时计数器变为0，表示锁被完全释放，其他线程可以获得 对象锁。

     

要明白两个问题，1.锁的对象是谁，2.谁持有了锁。
假设方法A和B是在同一个类Test中的两个方法。
      Test t=new Test();
       t.methodB();

       这个时候，methodB方法被调用时，因为加了synchronized ，需要先获得一个锁，这个锁的对象应该是t，也就是当前的这个Test类的实例，而获得锁的东西是线程，也就是说当前线程拿到了t的锁（而 不是你说的B方法获得锁），这个时候B方法内调用methodA，因为A也加了synchronized，也需要获得一个锁，因为A和B都是Test类中 的方法，所以当前线程要获得的锁的对象也是t。由于当前线程在执行B方法时已经持有了t对象的锁，因此这时候调用methodA是没有任何影响的，相当于 方法A上没有加synchronized。

另一种情况：假设现在有两个Test类
      Test t1=new Test();
      Test t2=new Test();
       t1.methodB();//此时当前线程持有了t1对象的锁
       t2.methodB();//此时当前线程也持有了t2对象的锁
当前线程持有了两把锁，锁的对象分别是两个不同的Test类的实例t1和t2，互相没有影响。

再一种情况：假设在多线程环境下，两个线程都可以访问Test t=new Test();
此时假设thread1里调用t.methodB();同时thread2里调用t.methodB()

这时假设thread1先抢到t对象的锁,那么thread2需要等待thread1释放t对象的锁才可以执行B方法。
结果像这样：
thread1获得t的锁--thread1执行methodB--thread1执行methodA--释放t的锁---thread2获得t的锁--thread2执行methodB--thread2执行methodA--释放t的锁。

synchronized还有很多种使用方法，但只有明白是那条线程获得哪个对象的锁，就很容易明白了。

 

在多线程中使用静态方法是否有线程安全问题

    类的成员分为两类，静态成员（static member）和实例成员(instance member)。静态成员属于类，实例成员则属于对象，即类的实例。

    简单讨论一下在一个类中使用静态字段(static field)和静态方法(static method)是否会有线程安全问题。 

    我们在知道, 静态字段(static field)和静态方法(static method)的调用是通过类来调用。静态方法不对特定的实例操作，只能访问静态成员。实例方法可对特定的实例操作，既能访问静态成员，也能访问实例成员。

    那么,在多线程中使用静态方法是否有线程安全问题?这要看静态方法是是引起线程安全问题要看在静态方法中是否使用了静态成员。

    因为，在多线程中使用同一个静态方法时，每个线程使用各自的实例字段(instance field)的副本，而共享一个静态字段(static field)。所以说，如果该静态方法不去操作一个静态成员，只在方法内部使用实例字段(instance field)，不会引起安全性问题。但是，如果该静态方法操作了一个静态字段，则需要静态方法中采用互斥访问的方式进行安全处理。

 

 

思考：

1.JAVA里静态的方法为什么不能存取“this"所引用的对象

首先要了解静态方法的加载和使用,静态方法也叫类方法。在类被加载的时候被初始化，可以通过类名和对象名进行调用，在类内部可以直接调用。仅该方法不需要实例化对象，即可调用。
在静态的方法中不能以任何形式引用this，因为this默认的对象引用，静态方法被调用时，this所引用的对象并没有产生,this无所指向.

 

转载：http://www.cnblogs.com/shipengzhi/articles/2223100.html
http://ayis.iteye.com/blog/315792
http://blog.163.com/lang_zi_ming/blog/static/114016176201082795254700/