Java锁机制Synchronized方法简介《三》

小结如下：

　　搞清楚synchronized锁定的是哪个对象，就能帮助我们设计更安全的多线程程序。

　　还有一些技巧可以让我们对共享资源的同步访问更加安全：

　　1. 定义private 的instance变量+它的 get方法，而不要定义public/protected的instance变量。如果将变量定义为public，对象在外界可以绕过同步方法的控制而直接取得它，并改动它。这也是JavaBean的标准实现方式之一。

　　2. 如果instance变量是一个对象，如数组或ArrayList什么的，那上述方法仍然不安全，因为当外界对象通过get方法拿到这个instance对象的引用后，又将其指向另一个对象，那么这个private变量也就变了，岂不是很危险。 这个时候就需要将get方法也加上synchronized同步，并且，只返回这个private对象的clone()――这样，调用端得到的就是对象副本的引用了。

　　// 以下是我学习过程中自己写的注释和例子，希望对大家有帮助!不妥之处望指出

　　/**

　　* java同步实现的两种方法，都是使用synchronized关键字：

　　* 1：实现时就是放该关键字到实例方法或类方法前面，如：public synchronized void method (){ }

　　* 2：采用synchronized块，使用如下：synchronized (Expression) { Block } 其中Expression为对象的引用，

　　* 在进入同步块Block之前，必须在Expression上取得锁。如果已有其他线程取得了这把锁，块便不能进入，

　　* 必须等候那把锁被释放。----表示只对Expression引用的对象才锁定代码块Block，对其它对象不锁

　　* 在方法前作为修饰词和用到statement块的差别在于：前者是在运行时实现锁功能，后者在编译时生成的class文件中体现锁机制。

　　*

　　* synchronized修饰方法时，表示该方法是同步的，同一时刻只能有一个线程使用它。

　　*

　　* 下面列出简单的synchronized方法：

　　* synchronized void f()

　　* synchronized void g()

　　* 每个对象都包含了一把锁(也叫作“监视器”)，它自动成为对象的一部分(不必为此写任何特殊的代码)。

　　* 调用任何synchronized方法时，对象就会被锁定，不可再调用那个对象的其他任何synchronized方法，

　　* 除非第一个方法完成了自己的工作，并解除锁定。在上面的例子中，如果为一个对象调用f()，便不能再为

　　* 同样的对象调用g()，除非f()完成并解除锁定。因此，一个特定对象的所有synchronized方法都共享着一把锁，

　　* 而且这把锁能防止多个方法对通用内存同时进行写操作(比如同时有多个线程)。

　　* 每个类也有自己的一把锁(作为类的Class对象的一部分)，所以synchronized static方法可在一个类的

　　* 范围内被相互间锁定起来，防止与static数据的接触。

　　*

　　* synchronized方法控制对类成员变量的访问：每个类实例对应一把锁，每个被synchronized的方法都必须获得

　　* 调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释

　　* 放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声

　　* 明为 synchronized 的成员函数中至多只有一个处于可执行状态(因为至多只有一个能够获得该类实例对应的锁)，

　　* 从而有效避免了类成员变量的访问冲突(只要所有可能访问类成员变量的方法均被声明为synchronized)。

　　* 也可以将类的静态成员函数声明为synchronized ，以控制其对类的静态成员变量的访问。

　　* synchronized方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类

　　* 的方法run()声明为synchronized，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何synchronized

　　* 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为synchronized，

　　* 并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是synchronized块。

　　*

　　* synchronized是对同一个对象而言的，即一个对象在执行被synchronized锁定的方法或者代码块时是同步的(不会被打断)

　　*

　　*/


　　public class ThreadTest {
　　private void method(Object o) throws InterruptedException{
　　Thread t=Thread.currentThread();
　　synchronized(t){
　　for(int i=0;i<10;i++){
　　System.out.print(t.getName()+" ");
　　Thread.sleep(100);
　　}
　　}
　　/*


　　* 把synchronized(t)换成synchronized(o)，比较运行结果

　　* synchronized(o)要求共用一把"锁",所以要求要用同一个对象

　　* synchronized(o)起到同步效果，synchronized(t)则没同步效果

　　* 还有：用synchronized修饰method(Object o)，看效果

　
　*/
　　}
　　public static void main(String args[]){
　　final ThreadTest th=new ThreadTest();
　　final Object o=new Object();
　　Thread t0=new Thread( new Runnable(){
　　public void run(){
　　System.out.println("\nT0 Start");
　　try {
　　th.method(o);
　　} catch (InterruptedException e){
　　e.printStackTrace();
　　}
　　System.out.println("\nT0 End");
　　}
　　});
　　Thread t1=new Thread( new Runnable(){
　　public void run(){
　　System.out.println("\nT1 Start");
　　try {
　　th.method(o);
　　} catch (InterruptedException e){
　　e.printStackTrace();
　　}
　　System.out.println("\nT1 End");
　　}
　　});
　　t0.start();
　　t1.start();
　　}
　　}