多线程学习（九）

最新推荐文章于 2024-09-27 12:05:02 发布

weixin_30568715

最新推荐文章于 2024-09-27 12:05:02 发布

阅读量74

点赞数

文章标签：开发工具

原文链接：http://www.cnblogs.com/joeCqupt/p/6825023.html

版权

原子类

JAVASE5 引入了诸如：AtomicInteger、AtomicLong、AtomicRenference等原子性变量，他们提供下面形式的原子性条件更新：
boolean cpmpareAndSet(exceptedValue,updateValue);
在常规编程中很难看见，在涉及性能调优的时候就有用武之地了。

public class AtomicIntegerTest implements Runnable {
    private AtomicInteger a = new AtomicInteger(0);

    public int getVal() {
        return a.get();
    }

    public void incr() {
        a.addAndGet(2);
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            incr();
        }
    }

    public static void main(String[] args) {
        new Timer().schedule(new TimerTask() {

            @Override
            public void run() {
                System.out.println("timer running");
                System.exit(0);
            }
        }, 5000); //定义一个定时器 来终止这个程序

        ExecutorService exec = Executors.newCachedThreadPool();
        AtomicIntegerTest at = new AtomicIntegerTest();
        exec.execute(at);
        exec.shutdown();//停止线程的提交，线程执行完之后尽快退出
        while (true) {
            int a = at.getVal();
            if(a%2!=0){
                System.out.println("found a error val:"+a);
                
            }
        }
    }
}

Atomic类是用来构建 juc 中的类的，只有在特殊的情况下才在自己的代码中使用他们，通常依赖于锁要更安全一些。（要么是synchronized 关键字要么是显示的Lock锁）

通过同步控制块，而不是对整个方法的进行同步，可以使多个任务访问对象的时间性能得到显著的提高。
下面是synchronized同步整个方法和同步代码块的性能比较

public class Pair {
    private int x;
    private int y;

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

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

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public void incrX() {
        x++;
    }

    public void incrY() {
        y++;
    }

    @SuppressWarnings("serial")
    public class NotEqualsException extends RuntimeException {

        @Override
        public String toString() {
            return "Pair X、Y not equals :pair:" + this;
        }

    }

    public void check() {
        if (x != y) {
            throw new NotEqualsException();
        }
    }

    @Override
    public synchronized String toString() {
        return "Pair [x=" + x + ", y=" + y + "]";
    }

}

public abstract class PairManager {
    /**
     * 记录check的次数
     */
    AtomicInteger checkTime = new AtomicInteger(0);

    protected Pair p = new Pair(); // 继承可得
    /**
     * 保存Pair对象
     */
    private List<Pair> storge = Collections.synchronizedList(new ArrayList<Pair>());

    public synchronized Pair getPair() {
        return new Pair(p.getX(), p.getY()); // 这里返回的是获取那一时刻的对象的副本
    }

    public void store(Pair p) {
        storge.add(p);
        /**
         * list线程不安全的原因： 一个 ArrayList ，在添加一个元素的时候，它可能会有两步来完成： 1. 在 Items[Size]
         * 的位置存放此元素； 2. 增大 Size 的值。 在单线程运行的情况下，如果 Size = 0，添加一个元素后，此元素在位置 0，而且
         * Size=1； 而如果是在多线程情况下，比如有两个线程，线程 A 先将元素存放在位置 0。但是此时 CPU 调度线程A暂停，线程 B
         * 得到运行的机会。线程B也向此 ArrayList 添加元素，因为此时 Size 仍然等于 0
         * （注意哦，我们假设的是添加一个元素是要两个步骤哦，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增加
         * Size 的值。 那好，现在我们来看看 ArrayList 的情况，元素实际上只有一个，存放在位置 0，而 Size 却等于
         * 2。这就是“线程不安全”了。
         */
    }

    public abstract void increment();

    @Override
    public String toString() {
        return "PairManager [checkTime=" + checkTime + ", pX=" + p.getX() + ",pY=" + p.getY() + "]";
    }

}

public class PairManager1 extends PairManager {

    @Override
    public synchronized void increment() {
        // TODO Auto-generated method stub
        p.incrX();
        p.incrY();
        store(getPair());
    }

}

public class PairManager2 extends PairManager {

    @Override
    public void increment() {
        Pair temp;
        synchronized (this) {
            p.incrX();
            p.incrY();
            temp=getPair();
        }
        store(temp);
    }

}

public class PairManager3 extends PairManager {
    private ReentrantLock lock=new ReentrantLock();
    @Override
    public  void increment() {
        // TODO Auto-generated method stub
        lock.lock();
        try{
            p.incrX();
            p.incrY();
            store(getPair());
        }finally {
            lock.unlock();
        }
    }

}

public class PairManager4 extends PairManager {
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void increment() {
        // TODO Auto-generated method stub
        Pair temp;
        lock.lock();
        try {
            p.incrX();
            p.incrY();
            temp = getPair();
        } finally {
            lock.unlock();
        }
        store(temp);
    }

}

public class PairManipulator implements Runnable {
    private PairManager pm;
    
    public PairManipulator(PairManager pm) {
        super();
        this.pm = pm;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true){
            pm.increment();
            try {
                TimeUnit.MILLISECONDS.sleep(10); //这里加这段代码是为了不让循环执行的太快导致线程栈溢出！！
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

public class PairChecker implements Runnable {
    private PairManager pm;

    public PairChecker(PairManager pm) {
        super();
        this.pm = pm;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            pm.checkTime.incrementAndGet();
            pm.getPair().check();
        }
    }

}

public class CriticalSection {
    static void test(PairManager p1, PairManager p2, PairManager p3, PairManager p4) {
        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {

            @Override
            public void uncaughtException(Thread t, Throwable e) {
                // TODO Auto-generated method stub
                System.out.println("Thread: " + t.getName() + " Exception:" + e);
            }
        });
        ExecutorService exec = Executors.newFixedThreadPool(8);
        PairManipulator pm1 = new PairManipulator(p1), pm2 = new PairManipulator(p2), pm3 = new PairManipulator(p3),
                pm4 = new PairManipulator(p4);
        PairChecker pc1 = new PairChecker(p1), pc2 = new PairChecker(p2), pc3 = new PairChecker(p3),
                pc4 = new PairChecker(p4);
        exec.execute(pm1);
        exec.execute(pm2);
        exec.execute(pm3);
        exec.execute(pm4);
        exec.execute(pc1);
        exec.execute(pc2);
        exec.execute(pc3);
        exec.execute(pc4);
        exec.shutdown();
        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("p1:" + p1 + "\np2:" + p2 + "\np3:" + p3 + "\np4:" + p4);
        System.exit(0);
    }

    public static void main(String[] args) {
        PairManager p1 = new PairManager1(), p2 = new PairManager2(), p3 = new PairManager3(), p4 = new PairManager4();
        test(p1, p2, p3, p4);
    }
}