package zuoye;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.ObjectInputStream.GetField;
import java.util.ArrayList;

import javax.swing.plaf.basic.BasicBorders.SplitPaneBorder;

import org.omg.CORBA.PUBLIC_MEMBER;

public class ZuoYe_05 {

        /**
         * 5： 读取 名单。txt中所有的人的名字 ，
开启两个线程模拟考试流程，所有的学生在 陈奕迅导师 或者 张学友导师 底下考试，
要求 输出格式：

        何镜波在张学友导师手下过了
        黄嘉俊在陈奕迅导师底下过了
                                        两个老师是随机切换的

        最后统计 两个导师底下个过了多少人
         * @throws IOException
         *                 1建立学术类继承Thread接口
         * 分析,2,第一步读取文档,将文档里的学生存储在一个集合中并将集合内容设置成静态共享
         *                 3,重写run方法,判断学生在线程跑,并输出
         *                 4,主方法调用启动get方法获得文档信息存在list集合
         *                 5,启动两个线程进行输出.
         */
        public static void main(String[] args) throws IOException {
                Student s = new Student();                                        //创建对象
                Student s1 = new Student();
                s.get();                                                                        //调用get方法给list集合赋值
                s.setName("张学友导师");                                                //设置名字
                s.setPriority(10);
                s1.setName("陈奕迅导师");
                s1.setPriority(10);
                s.start();                                                                        //启动线程
                s1.start();       
        }       
}

        class Student extends Thread{               
                private static ArrayList<String> list = new ArrayList<>();        //设置静态集合变量
                private static int i = 0;
                @Override
                public void run() {               
                        int count = 0 ;
                        int count1 = 0;
                       
                        while(true) {                               
                                synchronized (Student.class) {
                                        if (i==list.size()) {
                                                break;
                                        }
                                        try {
                                                sleep(10);
                                        } catch (InterruptedException e) {                                               
                                                e.printStackTrace();
                                        }
                                        if ("张学友导师".equals(getName())) {                                                //判断线程,
                                                System.out.println(list.get(i)+"在张学友导师手下过了");                //输出对应导师过的学生
                                                count++;
                                                i++;
                                        }else if("陈奕迅导师".equals(getName())){
                                                System.out.println(list.get(i)+"在陈奕迅导师手下过了");
                                                count1++;
                                                i++;
                                        }                               
                                }                               
                        }
                        System.out.println(count);
                        System.out.println(count1);
                }
                public static  ArrayList<String> get() throws IOException{
                        BufferedReader fis = new BufferedReader(new FileReader("名单.txt"));                //建立读取文档对象
                        String line;
                        while((line=fis.readLine())!=null){                                                                                       
                                list.add(line);                                                                                                //把每一个写入集合
                        }
                        fis.close();                                                                //关流
                        //System.out.println(list);
                        return list;
                }
               
        }
       
       

public class Test5 {
    private static BufferedReader br;
    static ArrayList<String> al;
    public int index = 0; //集合指针 方便判断所有线程的执行的次数
    static { //只加载一次
        try {
            String line;
            br = new BufferedReader(new FileReader("名单.txt"));
            al = new ArrayList<>();
            while ((line = br.readLine()) != null) {
                al.add(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                br.close(); //用完就关
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 模拟面试
     * 1.在主函数中加静态代码块，将名单文件信息存入集合中
     * 2.定义成员变量获取集合数据
     * 3.将集合和集合指针传入线程对象
     * 4.通过集合指针判断线程需要执行多少次
     * 5.定义线程对象的成员变量统计每个线程执行次数
     * 6.将结果保存到另一个文件中并关闭流
     *
     * @author purity 2016-10-21下午6:39:11-6:55 耗时16分钟
     */
    public static void main(String[] args) {
        Test5 t = new Test5();
        Exam exam=new Exam(al, t);
        new Thread(new Exam(al, t), "张学友导师").start(); //每new次，方便获取每个线程执行次数。(3个线程访问总次数正确)
        new Thread(new Exam(al, t), "陈奕迅导师").start(); //用线程的引用，不能获取每个线程执行次数 (3个线程访问总次数正确)
        new Thread(new Exam(al, t), "周杰伦导师").start();
    }
}

class Exam implements Runnable {
    static BufferedWriter bw;
    static {
        try {
            bw = new BufferedWriter(new FileWriter("a.txt"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private ArrayList<String> al;
    private Test5 t;

    public Exam(ArrayList<String> al, Test5 t) {
        this.al = al;
        this.t = t;
    }

    private int m = 0; // static被所有对象共享 就统计不出每个线程执行次数

    @Override
    public void run() {
        while (true) {
            synchronized (Exam.class) { //用字节码对象保证对象数据一致
                try {
                    Thread.sleep(10); // 放在同步块中 保证一条线程不会执行完或者线程不能随机访问
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String name = Thread.currentThread().getName();
                try {
                    if (t.index == al.size()) {
                        bw.write(name + "下通过了" + m + "人");
                        System.out.println(name + "下通过了" + m + "人");
                        bw.newLine();
                        bw.flush(); //将内存中的数据存入文件中
                        break;
                    }
                    m++;
                    System.out.println("恭喜" + al.get(t.index++) + "在" + name + "手下过了");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}