并发编程——java线程基础之线程同步

实现java线程同步的主要方法

• synchronized关键字
• 可重入锁

synchronized的应用

　　synchronized可以修饰代码块和方法，对代码块的加锁范围可以是类级别和对象级别，方法加锁本质上是对象级别加锁。

　　对象级别加锁

package base.synchronize;

public class Thread1 implements Runnable{
    private Object obj;
    
    public Thread1(Object obj) {
        this.obj = obj;
    }

    @Override
    public void run() {
        synchronized (obj) {
            System.out.println(Thread.currentThread().getName() + ": start...");
            try {
                Thread.sleep(10 * 1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ": end!");
        }
    }

}

package base.synchronize;

import org.junit.Test;

public class SynchronizeObject {
    public Object obj = new Object();
    
    @Test
    public void testFunc() {
        Thread t1 = new Thread(new Thread1(obj), "t1");
        Thread t2 = new Thread(new Thread1(obj), "t2");
        
        t1.start();
        t2.start();
        
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

　　类级别加锁

package base.synchronize;

public class Thread2 implements Runnable{

    @Override
    public void run() {
        synchronized (Thread2.class) {
            System.out.println(Thread.currentThread().getName() + ": start...");
            try {
                Thread.sleep(10 * 1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ": end!");
        }
    }

}

package base.synchronize;

import org.junit.Test;

public class SynchronizeClass {    
    @Test
    public void testFunc() {
        Thread t1 = new Thread(new Thread2(), "t1");
        Thread t2 = new Thread(new Thread2(), "t2");
        
        t1.start();
        t2.start();
        
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

　　方法级别加锁

package base.synchronize;

public class Thread3 implements Runnable{

    @Override
    public void run() {
        function();
    }
    
    public synchronized void function() {
        System.out.println(Thread.currentThread().getName() + ": start...");
        try {
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": end!");
    }

}

package base.synchronize;

import org.junit.Test;

public class SynchronizeFunc {
    @Test
    public void testFunc() {
        Thread3 t = new Thread3();
        Thread t3 = new Thread(t, "t3");
        Thread t4 = new Thread(t, "t4");
        
        t3.start();
        t4.start();
        
        try {
            t3.join();
            t4.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

可重入锁的应用

　　可重入锁（ReentrantLock）含义是，当一个线程获取了某一个可重入锁后可以再次去获取该可重入锁。其中分为普通的可重入锁以及读写锁。

　　可重入锁的使用

package base.lock;

import java.util.concurrent.locks.ReentrantLock;

public class Thread1 implements Runnable{
    private ReentrantLock lock;
    
    public Thread1(ReentrantLock lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + ": start...");
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": end.");
        lock.unlock();
    }

}

package base.lock;

import java.util.concurrent.locks.ReentrantLock;

import org.junit.Test;

public class LockMain {
    ReentrantLock lock = new ReentrantLock();
    
    @Test
    public void testCase() throws InterruptedException {
        Thread1 runnable = new Thread1(lock);
        Thread t1 = new Thread(runnable, "t1");
        Thread t2 = new Thread(runnable, "t2");
        
        t1.start();
        t2.start();
        
        t1.join();
        t2.join();
    }
}

　　读写锁的使用

　　读写锁，可以使用更细粒度的锁。读写锁的原则，读读共享、读写互斥、写写互斥。并且当有一个线程获取到了读锁且有一个线程获取写锁阻塞时，后来的读锁一定排队在该写锁之后才能获取资源，这是为了防止饥饿现象的发生（多运行几次读写混合客户端，观察不同的执行结果，分析执行结果不同的原因）

package base.lock.readwritelock;

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class Thread1 implements Runnable{
    private ReentrantReadWriteLock lock;
    
    public Thread1(ReentrantReadWriteLock lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        WriteLock writeLock = lock.writeLock();
        writeLock.lock();
        System.out.println(Thread.currentThread().getName() + ": 写数据start...");
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": 写数据end.");
        writeLock.unlock();

    }

}

package base.lock.readwritelock;

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;

public class Thread2 implements Runnable{
    private ReentrantReadWriteLock lock;
    
    public Thread2(ReentrantReadWriteLock lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        ReadLock readLock = lock.readLock();
        readLock.lock();
        System.out.println(Thread.currentThread().getName() + ": 读数据start...");
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": 读数据end.");
        readLock.unlock();

    }

}

package base.lock.readwritelock;

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;

public class Thread2 implements Runnable{
    private ReentrantReadWriteLock lock;
    
    public Thread2(ReentrantReadWriteLock lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        ReadLock readLock = lock.readLock();
        readLock.lock();
        System.out.println(Thread.currentThread().getName() + ": 读数据start...");
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": 读数据end.");
        readLock.unlock();

    }

}

package base.lock.readwritelock;

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

import org.junit.Test;

public class ReadLockMain {
    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
    @Test
    public void testCase() throws InterruptedException {
        
        Thread2 runnable = new Thread2(lock);
        Thread t1 = new Thread(runnable, "t1");
        Thread t2 = new Thread(runnable, "t2");

        t1.start();
        t2.start();
        
        t1.join();
        t2.join();
    }
}

package base.lock.readwritelock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

import org.junit.Test;

public class ReadWriteLockMain {
    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
    @Test
    public void testCase() throws InterruptedException {
        
        Thread1 runnable1 = new Thread1(lock);
        Thread2 runnable2 = new Thread2(lock);
        Thread t1 = new Thread(runnable1, "t1");
        Thread t2 = new Thread(runnable2, "t2");
        Thread t3 = new Thread(runnable2, "t3");

        t2.start();
        t1.start();
        t3.start();

        
        t1.join();
        t2.join();
        t3.join();
    }
}