Lock

最新推荐文章于 2024-12-23 12:14:00 发布

原创最新推荐文章于 2024-12-23 12:14:00 发布 · 170 阅读

0 ·

CC 4.0 BY-SA版权

多线程专栏收录该内容

14 篇文章

订阅专栏

本文深入探讨Java中线程锁机制的运用，包括ReentrantLock的非阻塞尝试获取锁特性，synchronized关键字的读写锁行为及其实现原理，以及ReentrantReadWriteLock如何实现读写分离锁定，提升并发效率。

package DSJ._01mythread.thread.lock;

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

/**
 * 观察现象：一个线程获得锁后，另一个线程取不到锁，不会一直等待
 * @author
 *
 */
public class MyTryLock {

	private static ArrayList<Integer> arrayList = new ArrayList<Integer>();
	static Lock lock = new ReentrantLock(); // 注意这个地方
	public static void main(String[] args) {
		
		new Thread() {
			public void run() {
				Thread thread = Thread.currentThread();
				boolean tryLock = lock.tryLock();
				System.out.println(thread.getName()+" "+tryLock);
				if (tryLock) {
					try {
						System.out.println(thread.getName() + "得到了锁");
						for (int i = 0; i < 5; i++) {
							arrayList.add(i);
						}
					} catch (Exception e) {
						// TODO: handle exception
					} finally {
						System.out.println(thread.getName() + "释放了锁");
						lock.unlock();
					}
				}
			};
		}.start();

		new Thread() {
			public void run() {
				Thread thread = Thread.currentThread();
				boolean tryLock = lock.tryLock();
				System.out.println(thread.getName()+" "+tryLock);
				if (tryLock) {
					try {
						System.out.println(thread.getName() + "得到了锁");
						for (int i = 0; i < 5; i++) {
							arrayList.add(i);
						}
					} catch (Exception e) {
						// TODO: handle exception
					} finally {
						System.out.println(thread.getName() + "释放了锁");
						lock.unlock();
					}
				}

			};
		}.start();
	}


}

package DSJ._01mythread.thread.lock;

public class MySynchronizedReadWrite {
    //  synchronized 读写方法是阻塞运行
    public static void main(String[] args) {

        final MySynchronizedReadWrite readWrite=new MySynchronizedReadWrite();

        new Thread(){
            @Override
            public void run() {
                readWrite.getWrite(Thread.currentThread());
            }
        }.start();




        new Thread(){
            @Override
            public void run() {
                readWrite.getWrite(Thread.currentThread());
            }
        }.start();
    }


    public synchronized void getWrite(Thread thread){

        long start = System.currentTimeMillis();
        int i=0;
        while(System.currentTimeMillis() - start <= 1) {
            i++;
            if(i%4==0){
                System.out.println(thread.getName()+"正在进行写操作");
            }else {
                System.out.println(thread.getName()+"正在进行读操作");
            }
        }
        System.out.println(thread.getName()+"读写操作完毕");
    }
}

//synchronized 读写方法是阻塞运行

package DSJ._01mythread.thread.lock;

public class MySynchronizedReadWrite {
    //  synchronized 读写方法是阻塞运行
    public static void main(String[] args) {

        final MySynchronizedReadWrite readWrite=new MySynchronizedReadWrite();

        new Thread(){
            @Override
            public void run() {
                readWrite.getWrite(Thread.currentThread());
            }
        }.start();




        new Thread(){
            @Override
            public void run() {
                readWrite.getWrite(Thread.currentThread());
            }
        }.start();
    }


    public synchronized void getWrite(Thread thread){

        long start = System.currentTimeMillis();
        int i=0;
        while(System.currentTimeMillis() - start <= 1) {
            i++;
            if(i%4==0){
                System.out.println(thread.getName()+"正在进行写操作");
            }else {
                System.out.println(thread.getName()+"正在进行读操作");
            }
        }
        System.out.println(thread.getName()+"读写操作完毕");
    }
}

//读操作并发，写操作阻塞

package DSJ._01mythread.thread.lock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 使用读写锁，可以实现读写分离锁定，读操作并发进行，写操作锁定单个线程
 *
 * 如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
 * 如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。
 * @author
 *
 */
public class MyReentrantReadWriteLock {
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    public static void main(String[] args)  {
        final MyReentrantReadWriteLock test = new MyReentrantReadWriteLock();

        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
                test.write(Thread.currentThread());
            };
        }.start();

        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
                test.write(Thread.currentThread());
            };
        }.start();

    }

    /**
     * 读操作,用读锁来锁定
     * @param thread
     */
    public void get(Thread thread) {
        rwl.readLock().lock();
        try {
            long start = System.currentTimeMillis();

            while(System.currentTimeMillis() - start <= 1) {
                System.out.println(thread.getName()+"---------GING正在进行读操作");
            }
            System.out.println(thread.getName()+"-------GDO读操作完毕");
        } finally {
            rwl.readLock().unlock();
        }
    }

    /**
     * 写操作，用写锁来锁定
     * @param thread
     */
    public void write(Thread thread) {
        rwl.writeLock().lock();;
        try {
            long start = System.currentTimeMillis();

            while(System.currentTimeMillis() - start <= 1) {
                System.out.println(thread.getName()+"-------WING正在进行写操作");
            }
            System.out.println(thread.getName()+"----------WDO写操作完毕");
        } finally {
            rwl.writeLock().unlock();
        }
    }
}