多线程实现的三种方式+静态代理

一、概念
程序、进程、线程

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

总结：启动一个应用（程序），系统会开启一个进程，一个进程里面可以有多个线程

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

二、线程实现
线程创建方式有三种
1、继承Thread类

步骤：
（1）继承Thread类
（2）重写run方法，方法里面编写线程需要处理的内容
（3）创建Thread对象，启动线程（调用start方法）

public class demo1 extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码----" + i);
        }
    }

    public static void main(String[] args) {
        //main线程，上线程
        //创建一个线程对象
        demo1 demo1= new demo1();
        //调用start（）开启线程
        demo1.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程----" + i);
        }
    }
}

2、实现runable接口(推荐使用)
由于java单继承的局限性，推荐使用该方式

步骤：
（1）自定义线程类实现Runable接口
（2）重写run方法，方法里面编写线程需要处理的内容
（3）创建Thread对象，启动线程（调用start方法）

public class Demo3 implements Runnable {

    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码----" + i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        Demo3 demo3 = new Demo3 ();
        //创建线程对象,通过线程对象来开启我们的线程,代理
        Thread thread = new Thread(demo3);
        //调用start（）开启线程
        thread.start();

        //new Thread(testThread).start();
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程----" + i);
        }
    }
}

案例：模拟龟兔赛跑

package com.sj.XC;

/**
 * 1、需要有个赛道，两个独立线程模拟兔子和乌龟
 * 2、判断比赛是否结束
 * 3、输出胜利者
 *
 */
public class Race implements Runnable {

    private static String winner;

        @Override
        public void run() {
            for (int i = 1; i <= 100; i++) {
                if(Thread.currentThread().getName().equals("兔子") && i%10==0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                gameover(i);
                System.out.println(Thread.currentThread().getName()+"跑了"+ i+"步");
            }
        }
        //判断是否完成比赛
        public boolean gameover(int step){
            if (winner != null){
                return true;
            }else {
                if(step >= 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接口

步骤：
（1）实现Callable接口，需要返回值类型
（2）重写call方法，需要抛出异常
（3）创建目标对象
（4）创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行：Future result1 = ser.submit(11);
获取结果：boolean r1 = result1.get()
关闭服务：ser.shutdownNow();

package com.sj.XC;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

public class demo4 implements Callable {
    private String url = null; //下载地址
    private String name = null;//保存文件名
    public demo4(String url,String name){
        this.url = url;
        this.name = name;
    }
    @Override
    public Object call() throws Exception {
        Load load = new Load();
        load.download(url,name);
        System.out.println("下载了文件："+name);
        return null;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        demo4 wan = new demo4("https://m701.music.126.net/20220918185217/cb5f8248b90e7d45b45215ca97af60e7/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/13505404461/3382/d0b6/42fe/5b554453f15a2df45750476914ffe1ce.m4a", "wan.m4a");
        demo4 m = new demo4("https://m701.music.126.net/20220918185217/cb5f8248b90e7d45b45215ca97af60e7/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/13505404461/3382/d0b6/42fe/5b554453f15a2df45750476914ffe1ce.m4a", "m.m4a");
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Future<Boolean> r = executorService.submit(wan);
        Future<Boolean> r1 = executorService.submit(m);
        r.get();
        r1.get();
        executorService.shutdownNow();
    }

}

/**
 * 下载器
 */
class Load{
    public void download(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
        }

    }

}

三、静态代理
Runable实现多线程用的就是静态代理模式
总结
真实对象和代理对象都要实现一个接口
代理对象要代理真实角色

好处
代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事