多线程基础回顾（二）-同步锁

线程同步方式

启动3个线程，目的打印出“abcabcabc”字样。

class Add implements Runnable{
    private static char[] arr={'a','b','c'};
    @Override
    public void run() {
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]);
        }
    }
}
public class ThreadTest{
    public static void main(String[] args) {
        Add add = new Add();
        new Thread(add).start();
        new Thread(add).start();
        new Thread(add).start();
    }
}

上边的代码是无法实现想要的结果，需要加入线程同步才行。

一、使用synchronized关键字

将上边的runable稍作修改

class Add implements Runnable{
    private static char[] arr={'a','b','c'};
    @Override
    public void run() {
        synchronized (this) {
            for(int i=0;i<arr.length;i++){
                System.out.print(arr[i]);
            }
        }
    }
}

 

这里this指实例本身，相当于实例方法同步。

1.实例方法同步：synchronized void method(){}

指同步在拥有该方法的对象上（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法。

2. 静态方法同步：synchronized static void method(){}

指同步在该方法所在的类对象上，它可以对类的所有对象实例起作用。

3. 实例方法中的同步块：synchronized(this){/区块/}

表示只对这个区块的资源实行互斥访问，括号内为监视器，（这里this为调用该方法的实例作为监视器，执行时和同步方法一样。）最简单的监听器：byte by = new byte[0];

4. synchronized关键字是不能继承的，

也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法。

---

二、使用Lock

ReentrantLock 重入锁：

• 可重入、互斥、实现了Lock接口的锁，功能同synchronized,更加灵活。
• 需手动释放锁，一般使用try...finally,防止异常死锁。

class Add implements Runnable{
    private Lock lock = new ReentrantLock();
    private static char[] arr={'a','b','c'};
    @Override
    public void run() {
        lock.lock();//获取锁
        try{
            for(int i=0;i<arr.length;i++){
                System.out.print(arr[i]);
            }
        }catch(Expetion e){
            //捕获操作
        }finally{
            lock.unlock();//手动释放锁
        }

    }
}

 

ReentrantReadWriteLock 读写锁，

• 读锁与写锁互斥。
• 读锁共享，可被多条线程同时占有。
• 写锁与读锁，写锁互斥，只能被一条线程占有。
• 锁降级：获取写锁，再获取读锁，再释放写锁，则降级为读锁。

class readAndWrite{
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock rl = lock.readLock();
    private final Lock wl = lock.writeLock();
    StringBuilder sb = new StringBuilder("start:");
    public void read(){
        String name = Thread.currentThread().getName();
        if(lock.isWriteLocked()){
            System.out.println(name+"：写锁被占有，无法获取读锁");
        }else{
            try{
                rl.lock();
                System.out.println(name+"：得到读锁");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                System.out.println(name+"：释放读锁");
                rl.unlock();
            }
        }
    }
    public void write(){
        String name = Thread.currentThread().getName();
        try{
            wl.lock();
            System.out.println(name+"：获取到写锁");
            sb.append(name+",");
        }finally{
            wl.unlock();
            System.out.println(name+"：释放写锁");
        }
    }
}
//测试
public class ThreadTest{
    public static void main(String[] args) {
        readAndWrite wr = new readAndWrite();
        ExecutorService ser1 = Executors.newFixedThreadPool(3);
        ExecutorService ser2 = Executors.newFixedThreadPool(3);
        for(int i=0;i<5;i++){
            ser1.execute(new Runnable() {
                @Override
                public void run() {
                    wr.write();
                }
            });
            ser2.execute(new Runnable() {
                @Override
                public void run() {
                    wr.read();
                }
            });
        }
        ser1.shutdown();
        ser2.shutdown();
        System.out.println("执行关闭线程池,sb="+wr.sb.toString());
        try {
                while(!ser1.awaitTermination(1000, TimeUnit.MILLISECONDS)) {
                System.out.println("等待线程池关闭");
                }
                System.out.println("线程池关闭,sb="+wr.sb.toString());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }
}

上边测试代码执行结果
pool-1-thread-1：获取到写锁
pool-1-thread-1：释放写锁
pool-2-thread-1：得到读锁
执行关闭线程池,sb=start:pool-1-thread-1,
pool-2-thread-1：释放读锁
pool-1-thread-2：获取到写锁
pool-1-thread-2：释放写锁
pool-2-thread-2：得到读锁
等待线程池关闭
pool-2-thread-2：释放读锁
pool-1-thread-3：获取到写锁
pool-1-thread-3：释放写锁
pool-2-thread-3：得到读锁
pool-2-thread-2：写锁被占有，无法获取读锁
等待线程池关闭
pool-2-thread-3：释放读锁
pool-1-thread-1：获取到写锁
pool-1-thread-1：释放写锁
pool-2-thread-1：得到读锁
等待线程池关闭
pool-2-thread-1：释放读锁
pool-1-thread-2：获取到写锁
pool-1-thread-2：释放写锁
等待线程池关闭
线程池关闭,sb=start:pool-1-thread-1,pool-1-thread-2,pool-1-thread-3,pool-1-thread-1,pool-1-thread-2,

三、使用volatile修饰符