线程的五大状态以及lambda推导

静态代理模式

• 静态代理模式
  真实对象和代理对象都要实现同一个接口
  代理对象要代理真实的角色
• 好处：
  代理对象可以做很多真实对象做不了的事情
  真实对象专注做自己的事情

public class StacticProxy {

    public static void main(String[] args) {
        new Thread( ()-> System.out.println("我爱你")).start();
        You you=new You();
        new WeddingCompany(new You()).HappyMarry();
        //WeddingCompany weddingCompany = new WeddingCompany(you);
        //weddingCompany.HappyMarry();
    }
}
interface Marry{
    void HappyMarry();
}

//结婚的真实角色
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("结婚很开心！");
    }
}
//代理模式,帮助你结婚
class WeddingCompany implements Marry{
    private Marry target;
    public WeddingCompany(Marry target) {
        this.target=target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    private void after() {
        System.out.println("结婚前，准备工作");
    }

    private void before() {
        System.out.println("结婚后，收尾工作");
    }
}

Lambda表达式

拓展：

函数式接口：
任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口
punlic interface Runnable{
public abstract void run();
}
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

1.lambda表达式的推导：

//推到lambda表达式
public class testLambda1 {

    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void Lambda() {
            System.out.println("I like lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like=new Like();//接口定义方法
        like.Lambda();

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


        //局部内部类
        class Like3 implements ILike{
            @Override
            public void Lambda() {
                System.out.println("I like lambda3");
            }
        }
        like=new Like3();
        like.Lambda();


        //5.匿名内部类，没有看类的名称，必须借助接口或者父类
        like=new ILike() {
            @Override
            public void Lambda() {
                System.out.println("I like lambda4");
            }
        };
        like.Lambda();
        //6.用lambda简化
        like=()-> {
            System.out.println("I like lambda5");
        };
        like.Lambda();
    }

}
//1.定义一个函数式接口
interface ILike{
    void Lambda();
}
//2.实现类
class Like implements ILike{
    @Override
    public void Lambda() {
        System.out.println("I like lambda");
    }

2.lambda表达式的简化：

ublic class testLambda2 {
    public static void main(String[] args) {
        ILove love =null;

//1.lambda表达式简化
       ILove love=(int a)-> {
           System.out.println("I Love You->"+a);
        };
       //2..简化1，去掉返回值类型
       love=(a)-> {
            System.out.println("I Love You->"+a);
        };
        //3.简化2，简化括号
       love=(a) -> {
            System.out.println("I Love You->"+a);
       };
       //如果只有一个参数，简化为一行代码
        love=a -> System.out.println("I Love You->"+a);
       love.love(520,521);
    }
}
interface ILove{
    void love(int a);
}

3.lambda表达式中有多个参数：

public static void main(String[] args) {
        IHit hit=null;
        hit=(a,b)->{
            System.out.println("I Hit You->"+a);
            System.out.println("I Hit You->"+b);
        };
        hit.hit(520,502);
    }
}
interface IHit{
    void hit(int a,int b);
}

线程停止

方法	说明
setPriority(int newPriority)	更改线程的优先级
static void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠
void join()	等待该线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程，别用这个方式
boolean isAlive()	测试线程是否处于活动状态

• 线程停止

public class TestStop implements Runnable{
//设置一个标识位
    private boolean flag=true;

    @Override
    public void run() {
        int i=0;
        while (flag){
            System.out.println("run....thread"+i++);
        }
    }
    //2.设置一个公开的方法停止线程，
    public void Stop(){
        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("main"+i);
            if (i==900){
                testStop.Stop();
                System.out.println("线程该停止");
            }
        }

    }
}

注意：
1.建议线程正常停止—>利用次数，不建议死循环
2.建议使用标志位—>设置一个标志位
3.不要使用stop和destroy等过时或者JDK不建议使用的方法

• 线程休眠

线程休眠
sleep（时间）指定当前线程阻塞的毫秒数
sleep存在异常InterruptedException
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延时，倒计时等
每一个对象都有一个锁，sleep不会释放锁

//十秒倒计时
public class testSleep2 {
    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0) {
                break;
            }
        }
    }
}

拓展：打印当前系统时间

 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();
            }

        }

运行结果为：

• 线程礼让-yield

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

public class testYield {
    public static void main(String[] args) {
        MyYield yield = new MyYield();
        new Thread(yield,"a").start();
        new Thread(yield,"b").start();
    }
}
class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

• 线程强制执行-join

join合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞
可以想像成插队

public class testJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            System.out.println("线程VIp来了"+i);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        testJoin tjoin = new testJoin();
        Thread thread = new Thread(tjoin);
        thread.start();
        //主线程
        for (int i = 0; i < 1000; i++) {
            if (i==200){
              thread.join();
            }
            System.out.println("main"+i);
        }
    }


}

观测线程的状态

 public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{

            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("///");
        });
        //观察状态
        Thread.State state=thread.getState();
        System.out.println(state);//new

        //观察启动后
        thread.start();//启动
        state=thread.getState();//更新线程状态
        System.out.println(state);

        //Thread.State.TERMINATED:线程终止的意思
        while (state!=Thread.State.TERMINATED){
            Thread.sleep(100);
            state=thread.getState();//更新线程状态
            System.out.println(state);//输出线程
        }
    }
}

运行结果:

线程的优先级

线程的优先级默认范围是1~10，主线程默认为优先级，一般注意是先设置优先级，然后在开启

public class testPriority  {
    public static void main(String[] args) {

        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority priority = new MyPriority();
        Thread t1 = new Thread(priority);
        Thread t2 = new Thread(priority);
        Thread t3 = new Thread(priority);
        Thread t4 = new Thread(priority);
        Thread t5 = new Thread(priority);
        Thread t6 = new Thread(priority);

        //先设置优先级，在启动
        t1.start();//默认为5

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(8);
        t4.start();

        t5.setPriority(6);
        t5.start();

        t6.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
        t6.start();
    }
}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

守护(daemon)线程

守护线程:

1. 线程分为用户线程和守护线程
2. 虚拟机必须确保用户线程执行完毕如：main()
3. 虚拟机不用等待用户守护线程执行完毕如：gc()
4. 如，后台记录操作日志，监控内存，垃圾回收等待

//测试守护线程，上帝守护着你的一生
public class testDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认为false,表示的是用户线程，正常的线程都是用户线程

        thread.start();//上帝守护线程开启
        new Thread(you).start();
    }
}
//上帝
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝保护着你");
        }
    }
}
//你
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("你开心的活着");
        }
        System.out.println("-----goodBye world!");
    }
}