java中实现同步的两种方式:syschronized和lock的区别和联系

   Lock是java.util.concurrent.locks包下的接口，Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题，我们拿Java线程(二)中的一个例子简单的实现一下和sychronized一样的效果，代码如下：

        这样就实现了和sychronized一样的同步效果，需要注意的是，用sychronized修饰的方法或者语句块在代码执行完之后锁自动释放，而用Lock需要我们手动释放锁，所以为了保证锁最终被释放(发生异常情况)，要把互斥区放在try内，释放锁放在finally内。

        如果说这就是Lock，那么它不能成为同步问题更完美的处理方式，下面要介绍的是读写锁(ReadWriteLock)，我们会有一种需求，在对数据进行读写的时候，为了保证数据的一致性和完整性，需要读和写是互斥的，写和写是互斥的，但是读和读是不需要互斥的，这样读和读不互斥性能更高些，来看一下不考虑互斥情况的代码原型：

        部分输出结果：

        我们要实现写入和写入互斥，读取和写入互斥，读取和读取互斥，在set和get方法加入sychronized修饰符：

        部分输出结果：

        我们发现，虽然写入和写入互斥了，读取和写入也互斥了，但是读取和读取之间也互斥了，不能并发执行，效率较低，用读写锁实现代码如下：

        部分输出结果：

        从结果可以看出实现了我们的需求，这只是锁的基本用法，锁的机制还需要继续深入学习。

        本文来自：高爽|Coder，原文地址：http://blog.csdn.net/ghsau/article/details/7461369，转载请注明。

在java中有两种方式实现原子性操作（即同步操作）：1）使用同步关键字synchronized2）使用lock锁机制其中也包括相应的读写锁

package com.xiaohao.test;

import java.util.Random;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReadWriteLock;import java.util.concurrent.locks.ReentrantLock;import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test {public static void main(String[] args) {final LockTest lock=new LockTest(); //输出张三 new Thread(){public void run(){ lock.test("张三张三张三张三张三张三张三张三张三张三");} }.start();//输出李四new Thread(){public void run(){lock.test("李四李四李四李四李四李四李四李四李四李四");System.out.println ("/n---------------------------------------------------------------");}}.start();//---------------------------------------------------------------//模拟写入数据的for (int i = 0; i < 3; i++) { new Thread(){ public void run() { for (int j = 0; j < 5; j++) { // lock.set(new Random().nextInt(30)); lock.set2(new Random().nextInt(30));

} } }.start();}//模拟读取数据的for (int i = 0; i < 3; i++) { new Thread(){ public void run() { for (int j = 0; j < 5; j++) { // lock.get(); lock.get2(); } } }.start();}}}

class LockTest{private Lock lock=new ReentrantLock(); //创建普通的锁private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();//创建读写锁private int data;// 共享数据 //实现同步的方法一 使用同步关键字 synchronizedpublic synchronized void test(String name){//下面的相关操作是一个原子性的操作// lock.lock();// 得到锁 try { for(int i = 0; i < name.length(); i++) { System.out.print(name.charAt(i)); } } finally { // lock.unlock();// 释放锁 } }//实现同步的方法二 使用lock锁机制public void test2(String name){//下面的相关操作是一个原子性的操作lock.lock();// 得到锁 try { for(int i = 0; i < name.length(); i++) { System.out.print(name.charAt(i)); } } finally { lock.unlock();// 释放锁 } }//使用set方法模拟写入数据 //使用 synchronized 实现了读读，写写，读写之间的互斥 ，但读读之间的互斥是没有什么必要的public synchronized void set(int data){System.out.println(Thread.currentThread().getName() + "准备写入数据"); try { Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } this.data = data; System.out.println(Thread.currentThread().getName() + "写入" + this.data); }//使用get方法模拟读取数据//使用 synchronized 实现了读读，写写，读写之间的互斥 ，但读读之间的互斥是没有什么必要的public synchronized void get() { System.out.println(Thread.currentThread().getName() + "准备读取数据"); try { Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "读取" + this.data); } //使用set方法模拟写入数据 //使用 读写锁实现了写写，读写之间的互斥 ，但读读之间的互斥是没有什么必要的public void set2(int data){readWriteLock.writeLock().lock();//获取写入锁try{System.out.println(Thread.currentThread().getName() + "准备写入数据"); try { Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } this.data = data; System.out.println(Thread.currentThread().getName() + "写入" + this.data); }finally{readWriteLock.writeLock().unlock();}}//使用get方法模拟读取数据//使用 读写锁实现了写写，读写之间的互斥 ，但读读之间的互斥是没有什么必要的public void get2() { //获取相应的读锁readWriteLock.readLock().lock();try{ System.out.println(Thread.currentThread().getName() + "准备读取数据"); try { Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "读取" + this.data); }finally{// 释放相应的写锁readWriteLock.readLock().unlock();}} }

线程同步经典版：

package com.xiaohao.test;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test2{

 public static void main(String[] args){

  final LockTest2 lockTest=new LockTest2();  

 for(int i=0;i<3;i++)   {    

new Thread(){        

  public void run(){         

        try {  

         for (int j = 0; j < 3; j++) {     

         lockTest.setValue();    

      }    } catch (InterruptedException e) {  

   // TODO Auto-generated catch block     e.printStackTrace();  

  }       

    }      

    }.start();  

 }  

 for(int i=0;i<3;i++)   {  

        new Thread(){     

      public void run(){                

   try {         

  for (int j = 0; j < 3; j++) { 

    lockTest.getValue();       

    }    

} catch (InterruptedException e)

{     // TODO Auto-generated catch block     e.printStackTrace();    }       

    }       

   }.start();  

}    

 }  

}

class  LockTest2 {

 int data=0;  

ReentrantReadWriteLock lock= new ReentrantReadWriteLock();// 锁对象

   public void setValue() throws InterruptedException{   

lock.writeLock().lock();  

 System.out.println("正在使用写锁......");    

data=(int) (Math.random()*10);   

 System.out.println("正在写入："+data);   

 Thread.sleep(500);  

 System.out.println("写锁调用完毕---------------------------");

  lock.writeLock().unlock();  }  

 public void getValue() throws InterruptedException{

  lock.readLock().lock();     

System.out.println("正在使用读锁...........................................");

   System.out.println("正在读入："+data);    Thread.sleep(500);

  System.out.println("读锁调用完毕......");

  lock.readLock().unlock();  

}

}

 **** 当一个线程进入了一个对象是的synchronized方法，那么其它线程还能掉否调用此对象的其它方法？

        这个问题需要分几种情况进行讨论。

      1）查看其它方法是否使用了同步关键字(synchronized)修饰，如果没有的话就可以调用相关的方法。

      2）在当前synchronized方法中是否调用了wait方法，如果调用了，则对应的锁已经释放，可以访问了。

      3）如果其它方法也使用synchronized修饰，并且当前同步方法中没有调用wait方法的话，这样是不允许访问的。

      4）如果其它方法是静态方法的话，由于静态方法和对象是扯不上什么关系，对于静态同步方法而言，其对应的同步监视器为当前类的字节码

           所以肯定可以访问的了。