如何在一个线程环境中使用一个线程非安全的java类

在开发过程中当我们拿到一个线程非安全的java类的时候，我们可以额外创建这个类的管理类并在管理类中控制同步

比如

一个非线程安全的Pair类

package test.thread.sx.testKuai;

/**

 *  线程非安全的java类

 *  约束条件 两个变量的值必须一致

 * @author Administrator

 *

 */

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++;

    }

    @Override

    public String toString() {

        return "Pair [x=" + x + ", y=" + y + "]";

    }

    public class PairValuesNotEqualException extends RuntimeException {

        private static final long serialVersionUID = 673137680063170443L;

        public PairValuesNotEqualException() {

            super("Pair value not equal" + Pair.this);

        }

    }

    public void checkState(){

        if(x!=y){

            throw new PairValuesNotEqualException();

        }

    }

}

那么我们想要在线程安全的环境下来操作这个类的话我们不可以修改原来类的代码结构我们可以创建一个新的管理类为了方便我们使用两种方式来实现同步

所以先创建一个abstract的类然后在创建这个类的实现类

package test.thread.sx.testKuai;

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 {

    protected Pair p = new Pair();

    protected List<Pair> storge = Collections.synchronizedList(new ArrayList<Pair>());

    /**

     * 获取pair可以轻松管理同步

     * @return

     */

    public synchronized Pair getPair(){

        return new Pair(p.getX(), p.getY());

    }

    public abstract void increment();

    public void storge(Pair p){

        storge.add(p);

    }

}

然后分别创建两个实现类一个是直接同步方法一个同步代码块

同步方法

package test.thread.sx.testKuai;

public class PairManager1 extends PairManager {

    @Override

    public synchronized void increment() {

        p.incrementX();

        p.incrementY();

        storge(getPair());

    }

}

同步代码块

package test.thread.sx.testKuai;

public class PairManger2 extends PairManager {

    @Override

    public void increment() {

        Pair temp;

        synchronized (this) {

            p.incrementX();

            p.incrementY();

            temp = getPair();

        }

        storge(temp);

    }

}

其实还可以直接替换 LOCK

package test.thread.sx.testKuai;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class PairManger2 extends PairManager {

    private Lock lock = new ReentrantLock();

    @Override

    public void increment() {

        Pair temp;

        /* synchronized (this) { */

        lock.lock();

        p.incrementX();

        p.incrementY();

        temp = getPair();

        lock.unlock();

        /* } */

        storge(temp);

    }

}

在保证线程安全的情况下为了性能最好是尽量减少同步范围

然后创建线程任务这个是两个变量同时增加的任务

package test.thread.sx.testKuai;

public class PairManipulator implements Runnable {

    private PairManager pm ;

    public PairManipulator(PairManager pm) {

        this.pm = pm;

    }

    @Override

    public void run() {

        while(true){

            pm.increment();

            System.out.println(pm.getPair());

        }

    }

    @Override

    public String toString() {

        return "pair:" + pm.getPair() ;

    }

}

然后创建一个检查任务

package test.thread.sx.testKuai;

public class PairChecker implements Runnable {

    private PairManager pm;

    public PairChecker(PairManager p) {

        pm = p;

    }

    @Override

    public void run() {

        while (true) {

        /*    pm.checkCounter.incrementAndGet();*/

            pm.getPair().checkState();

            System.out.println(pm.getPair());

        }

    }

}

然后进行测试

package test.thread.sx.testKuai;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

public class CiiticalSection {

    public static void testApproaches(PairManager pmn1,PairManager pmn2){

        ExecutorService exc = Executors.newCachedThreadPool();

        PairManipulator pm = new PairManipulator(pmn1);

        PairManipulator pm2 = new PairManipulator(pmn2);

        PairChecker pc = new PairChecker(pmn1);

        PairChecker pc2 = new PairChecker(pmn2);

        exc.execute(pm);

        exc.execute(pm2);

        exc.execute(pc);

        exc.execute(pc2);

        exc.shutdown();

    }

    public static void main(String[] args) {

        PairManager pmn1 = new PairManager1();

        PairManager pmn2 = new PairManger2();

        testApproaches(pmn1,pmn2);

    }

}

看下结果

-----------------

Pair [x=159948, y=159948]

Pair [x=159949, y=159949]

Pair [x=159950, y=159950]

--------------------

巴特西

如何在一个线程环境中使用一个线程非安全的java类

最新文章

热门文章