Thread多线程1-创建线程

线程简介

程序：是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念；
进程：执行程序的一次执行过程，是一个动态的概念，是系统资源分配的单位；
线程：在一个进程中可以包含若干个线程，一个进程至少有一个线程，线程是cpu调度和执行的单位；

【注意】很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换得很快，所以就有同时执行的错觉。

• 线程就是独立的执行路径；
• 程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程；
• main()称为主线程，为系统的入口，用于执行整个程序；
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的；
• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
• 线程会带来额外的开销，如CPU调度时间，并发控制开销；
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致；

线程创建（重点）

三种创建方式
1.继承Thread类（重点）
自定义线程类继承Thread类；
重写run()方法，编写线程执行体；
创建线程对象，调用start()方法启动线程；
【注意】线程开启，不一定立即执行，由cpu调度

**
 * 通过Thread创建线程
 */
public class ThreadCreate extends Thread{
    //线程入口
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程运行---"+i);
        }
    }

    public static void main(String[] args) throws Exception {
        //创建线程对象，启动线程
        ThreadCreate thread=new ThreadCreate();
        thread.start();
        //主线程
        for (int i = 0; i < 10; i++) {
            Thread.sleep(100);
            System.out.println("主线程运行****"+i);
        }
    }
}

2.实现Runnable接口（重点）
自定义Runnable类实现Runnable接口；
实现run()方法，编写线程执行体；
创建线程对象，调用start()方法启动线程；
【注意】推荐使用Runnable对象，因为java单继承的局限性

/**
 * 通过Runnable创建线程
 */
public class RunnableCreate implements Runnable{
    //线程入口
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程运行---"+i);
        }
    }

    public static void main(String[] args) throws Exception {
        //创建线程对象，启动线程
        RunnableCreate runnableCreate=new RunnableCreate();
        new Thread(runnableCreate).start();
        //主线程
        for (int i = 0; i < 10; i++) {
            Thread.sleep(100);
            System.out.println("主线程运行****"+i);
        }
    }
}

龟兔赛跑-Race

• 首先设置赛道距离，然后要离终点越来越近；
• 判断比赛是否结束；
• 打印出胜利者；
• 龟兔赛跑开始；
• 兔子需要睡觉，模拟延时；
• 终于乌龟赢得比赛;

/**
 * 模拟龟兔赛跑
 */
public class Race implements Runnable{
    //胜利者
    private static String winner=null;
    private static boolean isGameover=false;
    //赛跑
    @Override
    public void run() {
        for (int i = 1; i <=100; i++) { //100步的赛道
            //模拟兔子睡觉
            if(Thread.currentThread().getName().equals("兔子") && i%10==0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            isGameover=gameOver(i);
            if(isGameover){
                System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
                break;
            }
        }
    }
    //判断比赛是否结束
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if(winner!=null){
            return true;
        }
        if(steps>=100){
            winner=Thread.currentThread().getName();
            System.out.println("winner is "+winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Race race=new Race();
        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();
    }
}

3.实现callable接口（了解）

• 实现Callable接口，需要返回值类型；
• 重写call方法，需要抛出异常；
• 创建目标对象；
• 创建执行任务：ExecutorService ser=ExecutorService.newFixedThreadPool(1);
• 提交执行：Future result=ser.submit(t);
• 获取结果：Boolean b=result.get()
• 关闭服务：ser.shutdownNow();
  【优点】可以定义返回值；可以抛出异常

/**
 *Callable实现多线程下载图片
 */
public class CallableDemo implements Callable<Boolean> {
    private String url;
    private String name;

    public CallableDemo(String url, String name) {
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() {
        WebDownLoader webDownLoader = new WebDownLoader();
        webDownLoader.downloader(url, name);
        System.out.println("下载了文件名为：" + name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableDemo t1 = new CallableDemo("https://tenfei03.cfp.cn/creative/vcg/800/new/VCG211272502505-KDU.jpg", "1.jpg");
        CallableDemo t2 = new CallableDemo("https://alifei04.cfp.cn/creative/vcg/veer/1600water/veer-349391513.jpg", "2.jpg");
        CallableDemo t3 = new CallableDemo("https://tenfei03.cfp.cn/creative/vcg/veer/1600water/veer-360568807.jpg", "3.jpg");
        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //获取结果
        Boolean rs1=r1.get();
        Boolean rs2=r2.get();
        Boolean rs3=r3.get();
        System.out.println("执行结果：rs1="+rs1+",rs2="+rs2+",rs3="+rs3);
        //关闭服务
        ser.shutdown();
    }
}

4.静态代理模式

/**
 * 静态代理模式：
 * 1.真实对象和代理对象都要实现同一个接口；
 * 2.代理对象必须要代理真实角色；
 * 好处：
 * 1.代理对象可以做很多真实对象做不了的事情；
 * 2.真实对象专注做自己的事情；
 */
public class StaticProxy {
    public static void main(String[] args) {
        Person tom=new Person("Tom");//真实对象
        WedCompany wedCompany=new WedCompany(tom);//委托代理
        wedCompany.happyMarry();//代理业务
    }
}
interface Marry{
    void happyMarry();
}
//真实角色
class Person implements Marry{
    String name=null;
    public Person(String name){
        this.name=name;
    }
    @Override
    public void happyMarry() {
        System.out.println(this.name+" will be married");
    }
}
//代理角色
class WedCompany implements Marry{
    //代理谁->真实目标角色
    private Marry target;
    public WedCompany(Marry target){
        this.target=target;
    }
    @Override
    public void happyMarry() {
        before();
        this.target.happyMarry();//真实对象执行业务
        after();
    }
    private void before(){
        System.out.println("结婚前，布置现场");
    }
    private void after(){
        System.out.println("结婚后，收尾款");
    }
}

5.Lambda表达式

• 避免匿名内部类定义过多；
• 可以让代码看起来很简洁；
• 去掉没有意义的代码，只留下核心的逻辑和实质内容；
• 其实质属于函数式编程的概念；
  (params)->expression[表达式]
  (params)->statement[语句]
  (params)->

理解Functional Interface（函数式接口）是学习java8 lambda表达式的关键
函数式接口的定义：
任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口；

public interface Runnable{
    public abstract void run();
  }

对于函数式接口，可以通过lambda表达式来创建该接口的对象；

a->System.out.println("lambda-->"+a);
new Thread(()->System.out.println("多线程学习...").start();

/**
 * 推导lambda表达式
 */
public class LambdaDemo {
    //3.静态内部类
    static class YLike implements Like{
        @Override
        public void lambda() {
            System.out.println("You like limbda2");
        }
    }

    public static void main(String[] args) {
        Like like=new ILike();
        like.lambda();
        like=new YLike();
        like.lambda();

        //4.局部内部类
        class HLike implements Like{
            @Override
            public void lambda() {
                System.out.println("He likes lambda3");
            }
        }
        like=new HLike();
        like.lambda();

        //5.匿名内部类,没有类名，必须借助接口或父类
        like=new Like() {
            @Override
            public void lambda() {
                System.out.println("Anony likes lambda4");
            }
        };
        like.lambda();

        //6.用lambda简化
        //括号中放参数（可以不要参数类型），如只有一个参数可不要括号，
        //有多个参数用“,“分开并必须加括号。
        like=()-> {
            System.out.println("Lambda likes lambda5");
        };
        like.lambda();
    }
}
//1.定义一个函数式接口
interface Like{
    void lambda();
}
//2.实现类
class ILike implements Like{
    @Override
    public void lambda() {
        System.out.println("I like lambda1");
    }
}