Lock和读写锁ReadWriteLock和缓存实例

1：lock和synchronized对比

import
 java.util.concurrent.locks.Lock;
import
 java.util.concurrent.locks.ReentrantLock;


public
 
class
 LockTest {

    /**
     * @param args
     */
    public
 
static
 
void
 main(String[] args) {
        new
 LockTest().init();
    }

    private
 
void
 init(){
        final
 Outputer outputer = 
new
 Outputer();
        new
 Thread(
new
 Runnable(){
            @Override
            public
 
void
 run() {
                while
(
true
){
                    try
 {
                        Thread.sleep(10
);
                    } catch
 (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    outputer.output("zhangxiaoxiang"
);
                }

            }
        }).start();

        new
 Thread(
new
 Runnable(){
            @Override
            public
 
void
 run() {
                while
(
true
){
                    try
 {
                        Thread.sleep(10
);
                    } catch
 (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    outputer.output("lihuoming"
);
                }

            }
        }).start();

    }

    static
 
class
 Outputer{
        Lock lock = new
 ReentrantLock();
        public
 
void
 output(String name){
            int
 len = name.length();
            lock.lock();
            try
{
                for
(
int
 i=
0
;i<len;i++){
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }finally
{
                lock.unlock();
            }
        }

        public
 
synchronized
 
void
 output2(String name){
            int
 len = name.length();
            for
(
int
 i=
0
;i<len;i++){
                    System.out.print(name.charAt(i));
            }
            System.out.println();
        }

        public
 
static
 
synchronized
 
void
 output3(String name){
            int
 len = name.length();
            for
(
int
 i=
0
;i<len;i++){
                    System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }
}

2.读写锁：ReadWriteLock

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

public
 
class
 ReadWriteLockTest {
    public
 
static
 
void
 main(String[] args) {
        final
 Queue3 q3 = 
new
 Queue3();
        for
(
int
 i=
0
;i<
3
;i++)
        {
            new
 Thread(){
                public
 
void
 run(){
                    while
(
true
){
                        q3.get();
                    }
                }

            }.start();

            new
 Thread(){
                public
 
void
 run(){
                    while
(
true
){
                        q3.put(new
 Random().nextInt(
10000
));
                    }
                }

            }.start();
        }

    }
}

class
 Queue3{
    private
 Object data = 
null
;
//共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
    ReadWriteLock rwl = new
 ReentrantReadWriteLock();
    public
 
void
 get(){
        rwl.readLock().lock();
        try
 {
            System.out.println(Thread.currentThread().getName() + " be ready to read data!"
);
            Thread.sleep((long
)(Math.random()*
1000
));
            System.out.println(Thread.currentThread().getName() + "have read data :"
 + data);
        } catch
 (InterruptedException e) {
            e.printStackTrace();
        }finally
{
            rwl.readLock().unlock();
        }
    }

    public
 
void
 put(Object data){

        rwl.writeLock().lock();
        try
 {
            System.out.println(Thread.currentThread().getName() + " be ready to write data!"
);
            Thread.sleep((long
)(Math.random()*
1000
));
            this
.data = data;
            System.out.println(Thread.currentThread().getName() + " have write data: "
 + data);
        } catch
 (InterruptedException e) {
            e.printStackTrace();
        }finally
{
            rwl.writeLock().unlock();
        }


    }
}

3.用读写锁实现一个简单缓存机制

import
 java.util.HashMap;
import
 java.util.Map;
import
 java.util.concurrent.locks.ReadWriteLock;
import
 java.util.concurrent.locks.ReentrantReadWriteLock;

public
 
class
 CacheDemo {

    private
 Map<String, Object> cache = 
new
 HashMap<String, Object>();
    public
 
static
 
void
 main(String[] args) {
        // TODO Auto-generated method stub

    }

    private
 ReadWriteLock rwl = 
new
 ReentrantReadWriteLock();
    public
  Object getData(String key){
        rwl.readLock().lock();
        Object value = null
;
        try
{
            value = cache.get(key);
            if
(value == 
null
){
                rwl.readLock().unlock();
                rwl.writeLock().lock();
                try
{
                    if
(value==
null
){
                        value = "aaaa"
;
//实际失去queryDB();
                    }
                }finally
{
                    rwl.writeLock().unlock();
                }
                rwl.readLock().lock();
            }
        }finally
{
            rwl.readLock().unlock();
        }
        return
 value;
    }
}