玩玩Java多线程共享资源

玩玩Java多线程共享资源

1.实现效果与思路

需要达到的效果

• 一个集合里面有大量的数据，要求用多线程去操作该数据，线程处理完成后将结果返回给主线程

实现思路

• 在java中开启子线程有两种方式

  1.方式一：implements Runnable

  2.方式二：extends Thread

• 由于我们需要资源共享，所以选择了implements Runnable，并且使用线程池进行线程的控制

2.工作线程的实现逻辑

    package com.timmy008;

    import java.util.Map;
    import java.util.Map.Entry;

    /**
     * 工作线程
     * 
     * @author Administrator
     *
     */
    public class WorkerThread implements Runnable {

        /**
         * 任务的集合
         */
        private volatile Map<String, Work> maps;

        /**
         * 当前线程执行任务的结果
         */
        private volatile int result = 0;

        private ResultCallback mCallback;

        private boolean flag;

        public WorkerThread(Map<String, Work> maps) {
            super();
            this.maps = maps;
        }

        /**
         * 进行的工作
         */
        private void doWork() {
            for (Entry<String, Work> entry : maps.entrySet()) {
                synchronized (maps) {
                    Work value = entry.getValue();
                    if (value != null) {
                        if (!value.isRunning()) {
                            // TODO 这是执行任务
                            System.out.println("当前" + Thread.currentThread().getName() + "正在执行任务" + entry.getKey());
                            value.setRunning(true);
                            result += value.getWorking();
                        }
                    }
                }
            }
            if (mCallback != null && !flag) {
                flag =true;
                mCallback.onResult(result);
            }
        }

        public void setResultCallback(ResultCallback callback) {
            this.mCallback = callback;
        }

        @Override
        public void run() {
            doWork();
        }

    }

3.结果的回调

    package com.timmy008;

    /**
     * 结果的回调
     * @author Administrator
     *
     */
    public interface ResultCallback {

        /**
         * 返回结果
         *
         * @param result
         */
        void onResult(int result);
    }

4.具体的工作实体

    package com.timmy008;

    /**
     * 工作的实体
     * @author Administrator
     *
     */
    public class Work {
        /**
         * 是否运行
         */
        private boolean isRunning;

        /**
         * 具体工作
         */
        private int working;



        public Work(boolean isRunning, int working) {
            super();
            this.isRunning = isRunning;
            this.working = working;
        }

        public boolean isRunning() {
            return isRunning;
        }

        public void setRunning(boolean isRunning) {
            this.isRunning = isRunning;
        }

        public int getWorking() {
            return working;
        }

        public void setWorking(int working) {
            this.working = working;
        }

        @Override
        public String toString() {
            StringBuilder builder = new StringBuilder();
            builder.append("Work [isRunning=");
            builder.append(isRunning);
            builder.append(", working=");
            builder.append(working);
            builder.append("]");
            return builder.toString();
        }
    }

5.测试类

    package com.timmy008;

    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;

    public class Main {
        private static Map<String, Work> maps;

        public static void main(String[] args) {

            maps = new HashMap<>();
            Work work;
            for (int i = 0; i < 5000000; i++) {
                work = new Work(false, i);
                maps.put("当前是任务" + i, work);
            }

            ExecutorService service = Executors.newCachedThreadPool();

            WorkerThread workerThread1 = new WorkerThread(maps);
            workerThread1.setResultCallback(new ResultCallback() {

                @Override
                public void onResult(int result) {
                    System.out.println("计算出的结果:" + result);
                }
            });
            for (int i = 0; i < 10; i++) {
                service.execute(new Thread(workerThread1));
            }
            service.shutdown();// 执行完线程池中的线程后尽快退出

        }

    }

运行结果