阻塞线程---多线程（2）

package Lesson2;

public class InterruptThread {

    public static void main(String[] args) {
        /*
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        //start之后可能申请调度到了，也可能没到，可能执行到里面，也可能没有
        thread.interrupt();
        //有sleep在,他会抛一个异常，你现在在休眠，我要把你中断掉
        //线程处于sleep状态下，它发生中断会抛一个异常，铺货异常，
        //在catch里面执行一个中断的逻辑


     */
        Thread thread2=new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){

                }
            }
        });
        thread2.start();
        //start之后可能申请调度到了，也可能没到，可能执行到里面，也可能没有
        thread2.interrupt();
        //没有sleep就没有中断，其实什么都没有做，中断操作并没有发生
    }
}

package Lesson2;

import java.util.*;

public class ThreadAdvantage {

    public static List<String> randomList(){
        //取随机字符串
        char[] chars={'a','b','c','A','B','C'};//没写完，把字母都写进去
        List<String> list=new LinkedList<>();
        for(int i=0;i<100000;i++){
            //循环10万次，取10万个随机数
            int random=new Random().nextInt(chars.length);//相当于取数组的随机下标值
            char c=chars[random];
            //主要是取100000个，光写list.add(" ");一样的，上面是随机取字符串
            list.add(String.valueOf(c));
            //取一些放到list
        }
        return list;
    }
    public static void main(String[] args) throws InterruptedException {
        List<String> list=randomList();
        //建立10个线程，每个线程取10000个
        /*
        i=0;第一个线程，取1到10000个数，对应下标0到9999
        i=1;第二个线程，取10001到20000个数，对应下标10000到19999
         */
        //从1970年到现在的毫秒数
        //long start=new Date().getTime()
        Long start=System.currentTimeMillis();
        Thread[] threads=new Thread[10];
        for(int i=0;i<10;i++) {
            final int k = i;
            //匿名内部类内部的方法调用只能用外部的final量
            //有声明
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    //如果没有声明（threads[k]）,只是匿名类可以用Thread.currentThread()返回当前线程对象的引用
                    Thread current=Thread.currentThread();
                    System.out.println("id="+current.getId()+",name="+current.getName());
                    //System.out.println(Thread.currentThread().getName());
                    //System.out.println(threads[k].getName());
                    for (int j = 0; j < 10000; j++) {
                        list.get(k * 10000 + j);
                        //获取索引处元素
                    }
                }
            },"我的线程"+k);//加上k表示线程0，线程1，线程2....
            System.out.println(threads[i].getName());
            threads[i].start();
        }
            //第一种方法：线程让步：yield
            //当前线程活跃数大于1，肯定是大于1的，所以一定会进入循环
            /*
            idea会加入一个线程所以写2
            while(Thread.activeCount()>2){
            //处于运行态才会运行这个代码，表示放弃优先，而重新会带系统调度
                Thread.yield();
                //该方法是运行态变成就绪态
                //main线程让步不执行，先让其他线程执行
            }

             */
            //不写上面的while，就会选执行main线程,因为上面创建线程耗时，这样就无法计算时间

            //第二种方法：调用线程加入/等待：join
            for(Thread thread:threads){
                thread.join();
                //调用线程会一直执行，当前线程会一直等待(当前线程指的是join代码所在线程，
                // 所在作用域线程)，直到嗲用线程完毕
            }//每个线程都阻塞了
            long end=System.currentTimeMillis();
            //除以1000变秒
            System.out.println("耗时："+(end-start)+"毫秒");
            //10个线程同时去取都用15秒，因为在链表里面获取元素本来就很耗时
            //要是一个线程去取10万个数，的150秒
    }
    //sleep();运行态转阻塞态，转就绪态等待时间片去轮转，让程序休眠去调试
}