Java线程同步的实现

线程共享受限资源

1、基本上所有的并发模式在解决线程冲突的时候，都是采用 序列化访问共享资源的方案，这一位着在给定时刻只允许一个任务访问共享资源；

这通常是在代码前加上一条锁语句实现的，这种机制常常被称为 互斥量（mutex）；

2、隐式加锁同步：使用synchronized关键字

1）共享资源一般是以对象形式存在的 内存片段，但也可以是文件、输入/输出端口、打印机；

2）要控制共享资源的访问， 首先要将其包装进一个对象， 然后要将所有访问该资源的方法（或代码块）标记为synchronized；

     同时要将该共享域标记为private；

3）示例代码

1、对整个方法进行同步
class demo{
     private int shareResource;
     public synchronized void method1(){  shareResource ++;  }
     public synchronized void method2(){  shareResource --;  }
}
2、对方法中需要同步的地方进行同步
class demo{
     private int shareResource;
     public void method1(){
          System.out.println("method1 start");
          synchronized(this){
               shareResource ++; 
           } 
          System.out.println("method1 end"); 
     }
     public void method2(){
          System.out.println("method2 start");
          synchronized(this){
               shareResource --;
           }
          System.out.println("method2 end");
     }
}

4）对于 某个特定的对象来说，其范围内 所有的synchronized方法共享一个锁；

5）每个访问临界共享资源的方法都必须被同步，否则其他方法会随意忽视该锁；

3、显式加锁同步：利用Lock进行加锁

1）java SE5中的java.util.concurrent.Locks 可以显式地定义互斥机制；

2）示例代码

class Demo{
     private int shareResource;
     private Lock lock = new ReentrantLock();
     public int method{
          lock.lock();
          try{
               shareResource ++;
               return shareResource;
          }finallly{
               lock.unlock();
          }
     }//将同步块放置在try-finally块中，return必须在try块中，以确保unlock不会过早发生，从而将数据暴露给第二个任务；
}

3）使用synchronized隐式加锁的代码量更少， 通常在一些特殊情况下才会使用Lock对象，如：

①使用synchronized不能尝试获取锁，且最终获取锁失败时只会抛出一个异常，无法进行任何的清除工作；

②尝试获取锁一段时间，然后释放它；

class Demo{
     private Reentrantock lock = new ReentrantLock();
     public void method1(){
          boolean result = lock.tryLock();   //仅在调用时，lock处于空闲状态才获取锁；
          try{
               System.out.println(result);
          }finally{
               if(result)
                    lock.unlock();
          }
     }
     public void method2(){
          boolean result = false;
          try{
               result = lock.tryLock(2,TimeUnit.SECONDS); 
                //在调用时，lock在2seconds内处于空闲状态，且线程在这个时间段类没有被打断，才获取锁；
          }catch(InterruptedException e){
               System.out.println(result);
          }finally{
               if(result)
                    lock.unlock();
          }
     }

}

4、通过限制1个许可信号量来模拟一个互斥的锁（信号量时用来限制访问共享资源的线程数）

  class Task{
     Semaphore semaphore = new Semaphore(1);
     public void xMethod(){
           try{
                 semaphore.acquire();
                 statement;
           }catch(InterruptedException ex){
           }finally{
                 semaphore.release();
           }
     }
  }

5※、利用原子类取代synchronized互斥同步

1）原子性： 原子操作不需要进行同步控制，原子操作时不能被线程调度中断的操作，一旦操作开始，那么它一定可以在可能发生的“上下文切换”之前执行完毕，可以利用这一点的特定来编写 无锁的代码；

2）原子性可以应用在除了long和double之外的所有基本类型之上的“简单操作”，对于读写除了long和double之外的基本变量这样的操作，可以保证他们会被当做不可分割的操作来操作内存；

3）原子类：Java SE5引入了如AtomicInteger，AtomincLong，AtomicReference等特殊的原子性变量，它们提供以下形式的原子性条件更新操作：

这些类被调整为使用在某些现代处理器上可获得的，并且在机器级别上的原子性，一般应用在性能调优上；

boolean compareAndSet(expectedValue,updateValue); 当前值==预期值，则以原子方式将该值设置为给定的值

int getAndAdd(int delta);  以原子的形式将给定值与当前值相加

int getAndSet(int delta);  以原子形式将当前值设置为给定值

int get();

void set(int newValue);

如：AtomicInteger i = new AtomicInteger(1024);

    i.compareAndSet(1024,2048);   //该操作是线程安全的

4）示例代码

import java.util.concurrent.atomic.*;
class Demo{
     private AtomicInteger count = new AtomicInteger(0);
     public int getValue(){  return count.get(); }
     public void method1(){ count.getAndAdd(20)；}
     public void method2(){ count.getAndDerement(); //count++}
     public void method3(){ count.getAndIncrement(); //count--} 
     //Test
     public static void main(){
          Demo demo = new Deme();
          ExecutorService exec = Executors.newCachedThreadPool();
          exec.execute(new Runnable(){
               public void run(){
                    while(true){
                         demo.method1();
                         System.out.println(demo.getValue());
                    }
               }
          });
           exec.execute(new Runnable(){
               public void run(){
                    while(true){
                         demo.method2();
                         System.out.println(demo.getValue());
                    }
               }
          });
           exec.execute(new Runnable(){
               public void run(){
                    while(true){
                         demo.method3();
                         System.out..println(demo.getValue());
                    }
               }
          });
     }
}//对数据进行原子性操作，不用使用synchronized就可以对操作进行同步；

6、临界区

1）临界区（critical section）/同步控制块：有时候只是希望多个线程同时访问方法内部的部分代码，而不是整个方法，这种方式分离出来的代码块就是临界区；

synchronized(syncObject){

     statements;

}

2）在进入该同步控制块之前，必须获取syncObject对象的锁 ，如果其他线程已经获取该锁，那么要等到该锁释放后，才能进入该临界区；

3）使用同步控制块取代对整个方法进行同步控制 ，可以使多个任务访问对象的时间性能得到显著地提升；

4）synchronized块必须给定一个在其上进行同步的对象（一般比较合理的使用时synchronized（this）即本对象）；

     有时必须在另一个对象上同步，此时必须保证所有相关的任务都是在同一个对象上同步的， 此时两个同步控制块是相互独立的，他们不会因为对方而阻塞，示例：

//解决限制：一个对象只能获取一个同步锁————使得两个任务可以同时进入同一个对象
class Demo{
     private Object syncObject = new Object();
     public synchronized void method1(){
          while(true){
               println("method1()");
               Thread.yield();
          }
     }
     public void method2(){
          synchronized(syncObject){
               while(true){
                    println("method2()");
                    Thread.yield();
               }
          }
     }
    //Test
     public static void main(){
          final Demo demo = new Demo();
          new Thread(){
               public void run(){
                    demo.method1();
               }
          }
          demo.method2();
     }
}

7、线程本地储存ThreadLocal

1）除了以上使用互斥量同步的方法外，放置任务子在共享资源上产生冲突的第二种反方式 ：根除对变量的共享；

2）在java中的线程 本地储存是一种自动化机制， 可以为使用相同变量的每一个线程创建不同的储存，可以使用 java.lang.ThreadLocal 来实现；

3）实例代码

class Demo{
     private static ThreadLocal<Integer> value = new ThreadLocal<Integer>();
     value.set(0);
     public static void mian(String[] args){
          ExecutorService executor = Executors.newCachedThreadPool();
          for(int i=0;i<5;i++){
               executor.execute(new Runnable(){
                    public void run(){     
                         value.set(value.get()+i);
                         System.out.print(value.get()+",");
                    }
               });
          }
          TimeUnit.SECONDS.sleep(3);
          executor.shutdown();
     }
}/*output:
     0,1,2,3,4
*/
//只能使用set(),get()来修改和访问TreadLocal的数据；