java线程创建和lambda表达式----java多线程详解01

一、核心的线程概念

二、三种创建线程的方式

普通方法调用和多线程

1.继承Thread类（重点）
创建线程的方式一：继承Thread类，重写run()方法，调用start开启线程

多线程举例1

多线程实现同时下载多张图片

• 首先准备一个下载器，可以去网上下载，然后建立一个lib包，把这个下载器放入包中，并且转化为library。然后编写下载器类。
• 然后再来写线程类。重写run方法，在主方法中建立几个线程。
  第一步：编写下载器
  
  第二步:编写多线程
  
  2.实现Runnable接口（重点）
  
  通过runnable接口来实现线程举例
  
  3.上面两种方式的对比
  

4.实现Callable接口（了解）

举例对比说明


好处：可以提交返回值，可以返回异常
注意：当多个线程操作同一个资源的时候，可能会造成资源被线程重复占用的问题。

三、静态代理

1.真实对象和代理对象都要实现同一个接口
2.代理对象要代理真实角色
3.好处：
代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事情
静态代理举例
就像结婚时，你要请婚庆公司来给你做代理。（具体代码未贴）

四、Lamda表达式

1.定义

2.函数式接口的概念
一个接口里面只有一个抽象函数

3.为什么要使用lambda表达式

• 避免匿名内部类定义过多
• 可以让你的代码看起来更加的简洁
• 去掉了一堆没有用的代码，只留下核心的逻辑
  4.Lambda表达式举例

package com.oop;

/*
推导lamda表达式
 */
public class TestLamda {
    //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();
        //4.局部内部类
        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");
    }
}

5.lambda表达式简化举例以及使用总结

package com.oop;

public class TestLambda2 {

    public static void main(String[] args) {
        Ilove love = new Love();
        love.love(2);

        Ilove love1 = (int a)->{
            System.out.println("i love you--->"+a);
        };
        love1.love(520);
        //简化1：参数类型
        love = (a)->{
            System.out.println("i love you --->"+a);
        };
        //简化2：简化括号
        love = a->{
          System.out.println("i love you --->"+a);
        };
        love.love(521);

        //简化3：去掉花括号
        love = a->System.out.println("i love you--->"+a);
        love.love(666);
        //总结：
        /*
        1.lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就使用代码块
        2.前提是接口为函数式接口：即接口里面只有一个抽象方法
        3.多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号，不要只去掉一点点
        */
    }
}

//1.定义一个接口
interface Ilove{
    void love(int a);
}
//2.实现定义的接口
class Love implements Ilove{
    @Override
    public void love(int a) {
        System.out.println("I love you ---->"+a);
    }
}

五、线程状态

六、线程方法

1. 线程停止

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

package com.oop;
/*
1.建议线程正常停止--->利用次数，不建议死循环
2.建议使用标志位---->设置一个标志位
3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
 */
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");
            if (i==900)
            {
                //调用stop方法切换标志位，让线程停止
                teststop.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

2.线程休眠

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

package com.oop;

import jdk.nashorn.internal.ir.WhileNode;

public class TestSleep implements Runnable{

    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
                while (true){
                    if (ticketNums<=0)
                    {
                        break;
                    }else {
                        //模拟网络延时，放大问题的发生性，看出线程的不安全性
                        try{
                            Thread.sleep(100);
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"--->拿到了第"+ticketNums--+"票");
                    }

                }
    }

    public static void main(String[] args) {
        TestSleep ticket = new TestSleep();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"小青").start();
        new Thread(ticket,"黄牛党").start();
    }
}

• 线程休眠的举例2

package com.oop;

import javax.xml.crypto.Data;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestSleep2 {

    public static void main(String[] args) {
        tenDown();
        //打印当前系统时间
        Date startTime = new Date(System.currentTimeMillis());//获取当前系统时间
        while (true)
        {
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //模拟倒计时
    public static void tenDown(){
        int num = 10;
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}