多线程02

多线程02

1、lambda表达式

用于简化代码

前提：

• 必须有一个函数式接口(接口中只有一个方法)

注意：

• 括号内可以加参数，不写参数类型
• 执行语句只有一句时可以不写大括号

//堆到Lambda表达式
public class TestLambda {

    //3、静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda3");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();//用接口new了一个Like类对象
        like.lambda();

        like = new Like2();
        like.lambda();

        //4、局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        }

        like = new Like3();
        like.lambda();

        //5、匿名内部类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like lambda5");
            }
        };
        like.lambda();

        //6、lambda表达式
        like = ()->System.out.println("I like lambda6");
        like.lambda();
    }
}

//1、定义一个函数式接口
interface ILike{
    void lambda();
}

//2、实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}

---

2、线程停止

• 不要用过时的stop方法和destroy方法

1. 利用次数让线程正常停止，不建议死循环
2. 设置一个标志位结束循环

//跑两个线程，让副线程在500的时候停止，主线程跑完1000
public class TestStop implements Runnable{
    private boolean flag = true;//标志

    @Override
    public void run() {
        int i = 0;
        while(flag){//用循环结束线程
            System.out.println("副线程--->"+i++);
        }
    }

    //改变标志值，停止线程
    public void change(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();

        //格式
        new Thread(testStop).start();

        for (int i = 0; i <= 1000; i++) {
            System.out.println("主线程--->"+i);//主线程不受影响，跑完
            if(i==500){//当500时改变标志，结束副线程
                testStop.change();
                System.out.println("============");
                System.out.println("副线程已停止");
                System.out.println("============");
            }
        }
    }
}

---

3、线程休眠(延时)

• 主要用到sleep方法，指定当前线程阻塞的毫秒数
• 存在异常InterrutedException
• 时间到了恢复
• 模拟网络延时、倒计时等
• 每一个对象都一个锁,sleep不会释放锁

import java.text.SimpleDateFormat;
import java.util.Date;

//模拟网络延时:放大问题的发生性
//模拟倒计时
public class TestSleep{
    public static void main(String[] args) {
        Date startTime = new Date(System.currentTimeMillis());

        while (true){
            try {
                Thread.sleep(1000);//一秒打印一次
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis());//更新当前时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

---

4、线程礼让

• 让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• cpu重新调度，但不一定成功

//礼让线程
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}
class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程终止执行");
    }
}

---

5、Join

• 合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞
• 比如插队

//插队
//vip在普通用户200时插队，直到vip走完再走普通用户
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 1000; i++) {
            System.out.println("vip---> "+i);
        }
    }

    public static void main(String[] args) {
        TestJoin testJoin = new TestJoin();
        //new Thread(testJoin).start();//这样使用不了join方法
        Thread thread = new Thread(testJoin);

        //主线程
        for (int i = 0; i <= 500; i++) {
            if(i==200){
                thread.start();
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("普通用户--> "+i);
        }
    }
}