同步代码赏析

package com.test.multithreadDemo;

import java.io.*;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    private static final int count = 10000;
    private static final int threadGroupCount = 5;
    private static final String inputFIle = "testInput.txt";

    private static void generateTestFile() throws IOException {
        PrintWriter pw = new PrintWriter(new FileWriter(new File(inputFIle)));
        Random random = new Random();
        for (int i = 0; i < count; i++){
            pw.write(Math.abs(random.nextInt()) % count + ",");
        }
        pw.flush();
        pw.close();
    }

    public static void main(String [] args){
        try {
            generateTestFile();
            BufferedReader reader = new BufferedReader(new FileReader(inputFIle));
            String str = reader.readLine();
            reader.close();
            String[] strs = str.split(",");
            int index = 0;
            int countForEachFile = count / threadGroupCount;
            for (int i = 0; i < threadGroupCount; i++){
                int records[] = new int[countForEachFile];
                for (int j = 0; j < countForEachFile; j ++){
                    records[j] = Integer.parseInt(strs[index]);
                    index++;
                }
                PrintGroup group = new PrintGroup(records, i);
                ((PrintGroup) group).startPrint();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    static class PrintGroup{
        private static volatile int count = 0;
        private Lock lock = new ReentrantLock();
        private Condition oddLock = lock.newCondition();
        private Condition evenLock = lock.newCondition();
        private int records[];
        private PrintWriter writer;
        private volatile int oddIndex = 0;
        private volatile int evenIndex = 0;
        private OddPrintThread oddPrintThread;
        private EvenPrintThread evenPrintThread;
        private volatile boolean first = true;
        private int[] result = new int[2000];
        private int index = 0;

        public PrintGroup(int[] records, int id) throws Exception{
            this.records = records;
            this.writer = new PrintWriter(new FileWriter(new File("output" + id + ".txt")), true);
        }

        public void startPrint(){
            oddPrintThread = new OddPrintThread();
            evenPrintThread = new EvenPrintThread();
            oddPrintThread.start();
            evenPrintThread.start();
        }

        private class OddPrintThread extends Thread{
            @Override
            public void run(){
                while (true){
                    try {
                        lock.lock();
                        if (first){
                            first = false;
                            evenLock.await();
                        }
                        for (int i = 0; i < 10; ){
                            if (oddIndex >= records.length && evenIndex >= records.length){
                                writer.flush();
                                writer.close();
                                return;
                            }
                            if (oddIndex >= records.length){
                                break;
                            }
                            if (records[oddIndex] % 2 == 1 ) {
                                i++;
                                writer.print(records[oddIndex] + " ");
                                result[index++] = records[oddIndex];
                                writer.flush();
                                addCount();
                            }
                            oddIndex++;
                        }
                        oddLock.signal();
                        evenLock.await();
                    } catch (Exception e ){
                        e.printStackTrace();
                    } finally {
                        oddLock.signal();
                        lock.unlock();
                    }
                }
            }
        }

        private class EvenPrintThread extends Thread{
            @Override
            public void run(){
                while (true){
                    try {
                        while (first){
                            Thread.sleep(1);
                        }
                        lock.lock();
                        for (int i = 0; i < 10;){
                            if (oddIndex >= records.length && evenIndex >= records.length){
                                String s = "";
                                for (int k = 0; k < 2000; k++){
                                    s += (result[k] + "");
                                }
                                writer.flush();
                                return;
                            }
                            if (evenIndex >= records.length){
                                break;
                            }
                            if (records[evenIndex] % 2 == 0){
                                i++;
                                writer.print(records[evenIndex] + " ");
                                result[index++] = records[evenIndex];
                                writer.flush();
                                addCount();
                            }
                            evenIndex++;
                        }
                        evenLock.signal();
                        oddLock.await();
                    } catch (Exception e){
                        e.printStackTrace();
                    } finally {
                        evenLock.signal();
                        lock.unlock();
                    }
                }
            }
        }
        private synchronized static void addCount(){
            count++;
            if (count % 1000 == 0){
                System.out.println("已完成: " + count);
                if (count == 10000){
                    System.out.println("Done");
                }
            }
        }
    }
}