各种同步问题的代码(JAVA)

//synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法
//每个对象只有一个锁（lock）与之相关联。
//实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
/**//*
无论synchronized关键字加在方法上还是对象上，它取得的锁都是锁在了对象上，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
每个对象只有一个锁（lock）与之相关联。
实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
搞清楚synchronized锁定的是哪个对象，就能帮助我们设计更安全的多线程程序。
还有一些技巧可以让我们对共享资源的同步访问更加安全：
定义private 的instance变量+它的 get方法，而不要定义public/protected的instance变量。如果将变量定义为public，对象在外界可以绕过同步方法的控制而直接取得它，并改动它。
如果instance变量是一个对象，如数组或ArrayList什么的，那上述方法仍然不安全，因为当外界对象通过get方法拿到这个instance对象的引用后，又将其指向另一个对象，那么这个private变量也就变了，岂不是很危险。 这个时候就需要将get方法也加上synchronized同步，并且，只返回这个private对象的clone()――这样，调用端得到的就是对象副本的引用了。
*/
/**//*
Wait时别的线程可以访问锁定对象
调用wait方法的时候必需锁定该对象
Object提供的方法
Sleep时别的线程也不可以访问锁定对象
Thread提供的方法
*/


public class TestSync implements Runnable ...{
    Timer timer = new Timer();
    
    public static void main(String[] args) ...{
        TestSync test = new TestSync();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        
        t1.setName("t1"); 
        t2.setName("t2");
        t1.start(); 
        t2.start();
        //new Foo().methodBBB();
    }
  
    public void run()...{
        timer.add(Thread.currentThread().getName());
    }
}

class Timer...{
    private int num = 0;
    String s = "123";
    public void add(String name)...{ 
        synchronized (s) ...{    //    this只当前Timer对象
            num ++;
            try ...{Thread.sleep(1);} 
            catch (InterruptedException e) ...{}
            System.out.println(name+", 你是第"+num+"个使用timer的线程");
        }
    }

    public int readNum() ...{
        return num;
    }
}













/////////////////////////////////////////////////////////////////////////////////////////////////////////
//第一种情况
//修饰方法
//这也就是同步方法，那这时synchronized锁定的是哪个对象呢？
//它锁定的是调用这个同步方法对象。
//也就是说，当一个对象P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。
//但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法。
/////////////////////////////////////////////////////////////////////////////////////////////////////
/**//*
Public synchronized void methodAAA(){
    //……
}
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////






//////////////////////////////////////////////////////////////////////////////////////////////////
//第二种情况
//当有一个明确的对象作为锁时，就可以这样对so这个对象加锁,谁拿到这个锁谁就可以运行它所控制的那段代码
/**//*
public void method3(SomeObject so){
    synchronized(so){
        //……
    }
}
*/
////////////////////////////////////////////////////////////////////////////////////////////////////













///////////////////////////////////////////////////////////////////////////////////////////////
//第三种情况

//但当没有明确的对象作为锁，只是想让一段代码同步时，
//可以创建一个特殊的instance变量（它得是一个对象）来充当锁：

//注：零长度的byte数组对象创建起来将比任何对象都经济
//查看编译后的字节码：
//生成零长度的byte[]对象只需3条操作码，
//而Object lock = new Object()则需要7行操作码。

/**//*
class Foo implements Runnable{
    private byte[] lock = new byte[0];  // 特殊的instance变量
    Public void methodA(){
        synchronized(lock) {
            //…… 
        }
    }
    //……
}
*/
///////////////////////////////////////////////////////////////////////////////////////////////////






/////////////////////////////////////////////////////////////////////////////////////////////////
//第四种情况
//将synchronized作用于static 函数，示例代码如下
//代码中的methodBBB()方法是把class literal作为锁的情况，它和同步的static函数产生的效果是一样的，
//取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。
//------>下面的说法可能有问题!
//如果一个类中定义了一个synchronized的static函数A，也定义了一个synchronized 的instance函数B，
//那么这个类的同一对象Obj在多线程中分别访问A和B两个方法时，不会构成同步，
//因为它们的锁都不一样。A方法的锁是Obj这个对象，而B的锁是Obj所属的那个Class。 
/**//*
class Foo {
    public synchronized static void methodAAA(){   // 同步的static 函数
        try {Thread.sleep(1000);}catch (InterruptedException e) {}
        System.out.println("methodAAA......");
    }
    public void methodBBB(){
        synchronized(Foo.class){   //  class literal(类名称字面常量)
        }
        System.out.println(Foo.class.getName() + ".class");
    }
}
*/
////////////////////////////////////////////////////////////////////////////////////////////////////



补充：

class Foo ...{
    static Foo foo = new Foo();
    // 同步的static 函数
    public synchronized static void methodAAA()...{
        System.out.println("methodAAA......");
        try ...{
            Thread.sleep(5000);
        }catch (InterruptedException e) ...{
            
        }
    }
    // 同步Foo.class.....说明:class literal(类名称字面常量)
    public void methodBBB()...{
        synchronized(Foo.class)...{
            System.out.println(Foo.class.getName() + ".class");
            try ...{
                Thread.sleep(5000);
            }catch (InterruptedException e) ...{
                
            }
        }
        
    }
    //普通方法
    public void methodCCC()...{
        System.out.println("generic method ......");
        try ...{
            Thread.sleep(5000);
        }catch (InterruptedException e) ...{
            
        }
    }
}

class TestFoo...{
    public static void main(String [] args)...{
        
        //通过不同的实例调用methodAAA
        //new Thread(new A()).start();
        //new Thread(new A()).start();
        
        //通过不同的实例调用methodBBB
        //new Thread(new B()).start();
        //new Thread(new B()).start();
        
        //通过不同的实例调用methodAAA和methodBBB
        //new Thread(new A()).start();
        //new Thread(new B()).start();
        
                
        //通过相同的实例调用methodAAA
        //new Thread(new AA()).start();
        //new Thread(new AA()).start();
        
        //通过相同的实例调用methodBBB
        //new Thread(new BB()).start();
        //new Thread(new BB()).start();
        
        //通过相同的实例调用methodAAA和methodBBB
        //new Thread(new AA()).start();
        //new Thread(new BB()).start();
        
        //调用普通方法
        //Foo.foo.methodCCC();

    }
}

class A implements Runnable ...{
    public void run() ...{
        new Foo().methodAAA();
    }
}

class B implements Runnable ...{
    public void run() ...{
        new Foo().methodBBB();
    }
}

class AA implements Runnable ...{
    public void run() ...{
        Foo.foo.methodAAA();
    }
}

class BB implements Runnable ...{
    public void run() ...{
        Foo.foo.methodBBB();
    }
}