并发（二）

本篇讲述一下多线程中，共享受限资源。

本文只是自己学习过程中的总结，知识点整理，会引用书中或是他人大量的代码或是观点。我会尽量标记出处。

 参考文章：

http://blog.csdn.net/luoweifu/article/details/46613015

《Java编程思想》     参考了许多代码和观点，在此声明。

1.不正确的访问资源

请看例子：

public class ThreadDemo02 implements Runnable{

    private static int i = 0;
    
    public void run() {
        //synchronized (this) {
            System.out.println(Thread.currentThread().getName() + " i value is " + i++);
        //}
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadDemo03 {

    public static void main(String[] args) throws InterruptedException {

        ThreadDemo02 demo02 = new  ThreadDemo02();
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            service.execute(demo02);
        }
        service.shutdown();
    }
}

这是实际执行的结果：

pool-1-thread-2 i value is 0
pool-1-thread-6 i value is 3
pool-1-thread-3 i value is 1
pool-1-thread-4 i value is 2
pool-1-thread-1 i value is 0
pool-1-thread-5 i value is 5
pool-1-thread-7 i value is 4
pool-1-thread-8 i value is 6
pool-1-thread-3 i value is 7
pool-1-thread-8 i value is 8

而我期待的结果是下面这样的：

pool-1-thread-1 i value is 0
pool-1-thread-6 i value is 1
pool-1-thread-5 i value is 2
pool-1-thread-7 i value is 3
pool-1-thread-4 i value is 4
pool-1-thread-3 i value is 5
pool-1-thread-2 i value is 6
pool-1-thread-8 i value is 7
pool-1-thread-5 i value is 8
pool-1-thread-8 i value is 9

这是因为共享资源竞争造成的结果。

 

2.解决共享资源竞争

 2.1第一种方式是使用synchronized的方式。

在这里需要注意的是，synchronized锁的对象指的是同一对象内的。如果有两个对象，那么就会有两把锁，两把锁之间相互独立，没有影响。

在使用并发时，将域设置为private是非常重要的，否则，synchronized关键字就不能防止其他任务直接访问域，这样就会产生冲突。

syschronized是Java中的关键字，它修饰的对象有以下几种：

（1）修饰域，被称为同步代码块，作用的对象是调用这个方法的对象；

（2）修饰方法，作用的范围是整个方法，作用的对象是调用这个方法的对象；

（3）修饰静态方法，作用的对象是这个类的所有对象；

（4）修饰类，作用的对象是整个类的所有的对象。

 

 在用synchronized修饰方法时要注意以下几点：

（1）synchronized关键字不能被继承。虽然，可以使用synchronized来定义方法，但是synchronized并不属于方法定义的一部分，因此它不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，那么子类的这个方法默认情况下并不是同步的，而必须显示第在子类的这个方法中加上synchronized关键字。当然，还可以在子类中调用父类的方法，虽然子类中的方法不是同步的，但是子类调用了父类的同步方法，因此，子类的方法也就相当于是同步了。

（2）构造方法不能使用synchronized关键字，但是在方法内部可以使用synchronized代码块。

（3）下面使用synchronized的方式是等价的。

public synchronized void method {
    // to do
}

public void method {
    synchronized(this) {
        
    }
}

 

2.2使用显示的Lock对象

Lock对象必须被显式第创建、锁定、和释放，跟内建的锁形式相比，代码缺乏优雅性，但是更加灵活，赋予了你更加细粒度的控制力。这对于实现专用结构是很有用的，例如用于遍历链表中的节点的节节传递的加锁机制，这种遍历代码必须在释放当前节点的锁之前捕获下一个节点的锁。(红色部分观点摘自《Java 编程思想》)

这里我将JDBC的transaction联系起来，觉得这样大家会更好理解。

自己去设置上锁和解锁的时间点，跟事务开始结束的设置，我认为是一样的。

 lock的代码如下：

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

public class ThreadDemo02_lock implements Runnable{

    private static int i = 0;
    private Lock lock = new ReentrantLock();
    public void run() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " i value is " + i++);
        } finally {
            lock.unlock();
        }
    }
}

 

2.3原子性和易变性

原子性可应用于除long和double之外的所有基本类型之上的简单操作。但是当你定义long或double变量时，如果使用volatile关键字时，就会获得原子性。

volatile关键字确保了应用中的可见性。如果将一个域声明为volatile，那么是要对这个域产生了写操作，那么所有的读操作就都可以看到这个修改。

如果多个任务在同时访问某个域，那么这个域就应该是volatile的，否则，这个域就应该只能由同步来访问。

记住第一选择是synchronized，这是最安全的，而尝试其他任何方式都是有风险的。

在java中， i++等操作不是原子性的。

下面看一个例子：

public class ThreadDemo04 implements Runnable{

    private int i=0;
    
    // 为了保证获取I的数值时，能达到稳定状态，应该同步地使用getValue，也就是加上synchronized关键字
    public int getValue() {
        // 虽然return i是原子性操作，但是缺少同步使得其数值可以在处于不稳定的中间状态时被读取。
        return i;
    }
    
    @Override
    public void run() {
        while (true) {
            evenIncrement();
        }
    }

    private synchronized void evenIncrement() {
        i++;
        i++;
    }

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        ThreadDemo04 demo04 = new ThreadDemo04();
        service.execute(demo04);
        while (true) {
            int val = demo04.getValue();
            if(val%2 != 0) {
                System.out.println(val);
                System.exit(0);
            }
        }
    }
}

 

2.4临界区

 也称为同步控制块。进入代码之前，必须得到对象的锁，如果其他线程已经得到这个锁，那么就得等到锁被释放以后，才能进入临界区。

public class Pair {

    private int x, y;

    public Pair(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public Pair() {
        this(0, 0);
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public void incrementX() {
        x++;
    }

    public void incrementY() {
        y++;
    }

    public String toString() {
        return "x: " + x + ", y: " + y;
    }
    
    public class PairValuesNotEquationException extends RuntimeException {

        private static final long serialVersionUID = 1L;
        
        public PairValuesNotEquationException(){
            super("Pair values not equal: " + Pair.this);
        }
    }
    
    public void checkState() {
        if (x != y) {
            throw new PairValuesNotEquationException();
        }
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public abstract class PairManager {

    AtomicInteger checkCounter = new AtomicInteger(0);
    protected Pair p = new Pair();
    private List<Pair> storange = Collections.synchronizedList(new ArrayList<Pair>());
    public synchronized Pair getPair() {
        return new Pair(p.getX(), p.getY());
    }
    protected void store(Pair p){
        storange.add(p);
        try {
            TimeUnit.MICROSECONDS.sleep(50);
        } catch (InterruptedException ignore){
            
        }
    }
    
    public abstract void increment();
}

public class PairManager1 extends PairManager {

    @Override
    public synchronized void increment() {
        p.incrementX();
        p.incrementY();
        store(getPair());
    }

}

public class PairManager2 extends PairManager {

    @Override
    public void increment() {

        Pair pair;
        synchronized (this) {
            p.incrementX();
            p.incrementY();
            pair = getPair();
        }
        store(pair);
    }

}

public class PairManipulator implements Runnable {

    private PairManager pm;
    public PairManipulator(PairManager pm) {
        this.pm = pm;
    }
    @Override
    public void run() {

        while (true) {
            pm.increment();
        }
    }
    
    public String toString () {
        return "Pair: " + pm.getPair() + " checkCounter = " + pm.checkCounter.get();
    }

}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class CriticalSection {

    static void testApproaches(PairManager pman1 , PairManager pman2) {
        ExecutorService exec = Executors.newCachedThreadPool();
        PairManipulator pm1 = new PairManipulator(pman1);
        PairManipulator pm2 = new PairManipulator(pman2);
        PairChecker pch1 = new PairChecker(pman1);
        PairChecker pch12= new PairChecker(pman2);
        exec.execute(pm1);
        exec.execute(pm2);
        exec.execute(pch1);
        exec.execute(pch12);
        try {
            TimeUnit.MICROSECONDS.sleep(500);
        } catch (InterruptedException ex) {
            System.out.println("sleep intertuped");
        }
        System.out.println("pm1: " + pm1 + "\npm2: " + pm2);
        System.exit(0);
    }
    
    public static void main(String[] args){
        PairManager pm1 = new PairManager1();
        PairManager pm2 = new PairManager2();
        testApproaches(pm1, pm2);
    }
}

上面这个完成的例子，执行完后，就可以看到结果，从结果中可以看到同步控制块的效率要远高于同步方法。此外，也展示了如何把一个非保护类型的类，在其他类的保护和控制之下，应用于多线程的环境。

 

2.5在其他对象上同步

下面的示例展示了两个任务可以同时进入同一个对象，只要这个对象的方法是在不同的锁上同步的即可。

public class DualSynch {

    private Object object = new Object();
    public synchronized void f() {
        for (int i = 0; i < 5; i++) {
            System.out.println("f()");
            Thread.yield();
        }
    }
    
    public void g() {
        synchronized (object) {
            for (int i = 0; i < 5; i++) {
                System.out.println("g()");
                Thread.yield();
            }
        }
    }
}

public class SyncObject {

    public static void main(String[] args) {

        final DualSynch dualSynch = new DualSynch();

        new Thread(()-> dualSynch.f()).start();
/*        new Thread() {
            public void run() {
                dualSynch.f();
            }
        }.start();*/
        dualSynch.g();
    }
}

 

2.6线程本地存储

线程本地存储是一种自动化机制，可以为使用相同变量的每个不同的线程都创建不同的存储。

例子如下：

public class Accessor implements Runnable {

    private final int id;
    public Accessor (int idn) {
        id = idn;
    }
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            ThreadLocalVariableHolder.increment();
            System.out.println(this);
            Thread.yield();
            }
    }

    public String toString() {
        return "#" + id + ": " + ThreadLocalVariableHolder.get();
    }
}

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadLocalVariableHolder {

    private static ThreadLocal<Integer> value = new ThreadLocal<Integer>() {
        private Random rand = new Random(47);

        protected synchronized Integer initialValue() {
            return rand.nextInt(100);
        }
    };

    public static void increment() {
        value.set(value.get() + 1);
    }

    public static int get() {
        return value.get();
    }
    public static void main(String[] args) throws InterruptedException {

        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 4; i++) {

            service.execute(new Accessor(i));
        }
        TimeUnit.SECONDS.sleep(1);
        service.shutdownNow();
    }

}

 

写到这里，这部分算是完事了，之而的文章将进入下一小节的学习了。