Java线程的两种实现方式

- 基本概念
程序：程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
进程：执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位。
线程：通常一个进程包含多个线程，线程是CPU调度和执行的单位。

核心概念

线程是独立的执行路径

在程序运行时，即使自己没有创建线程，后台也会有多个线程，如主线程、gc线程（守护线程）

main()称之为主线程，为系统的入口，用于执行整个程序（用户线程）

在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是操作系统密切相关，先后顺序不能干预

对同一份资源操作时，会存在资源抢夺问题，需要加入并发控制

线程会带来额外的开销，如cpu调度时间，并发控制开销

每个线程在自己的工作内存中交互，内存控制不当会造成数据的不一致。
线程的三种实现方式：

继承Thread类，线程开启不一定立即执行，由CPU调度

//创建线程的第一种方式：继承Thread类,重写run方法，调用start方法开启线程
public class TestThread  extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程"+i);
        }
        //调用线程,开启线程
        TestThread testThread=new TestThread();
        testThread.start();
    }
}

实战Thread：

import java.io.File;
import java.io.IOException;
import java.net.URL;

//练习Thread，实现多线程同步下载图片
public class TestThread2 extends Thread{
    private String url;
    private String name;

    public TestThread2(String url, String name) {
        this.url = url;
        this.name = name;
    }
//下载图片线程的执行体
    @Override
    public void run() {
        WebDownLoader webDownLoader=new WebDownLoader();
        webDownLoader.downloader(url,name);
        System.out.println("下载了文件"+name);
    }
    public static void main(String[] args) {
        TestThread2 thread1=new TestThread2("https://img.xmqmnet.com/uploads/picture/2022-03-24/ef476197d40f822f1bf253781d18f890.jpg","tupian1");
        TestThread2 thread2=new TestThread2("https://img.xmqmnet.com/uploads/picture/2022-03-24/ef476197d40f822f1bf253781d18f890.jpg","tupian2");
        TestThread2 thread21=new TestThread2("https://img.xmqmnet.com/uploads/picture/2022-03-24/0962d0caf237de7fb286cb199d033a6f.jpg","tupian3");
        thread1.start();
        thread2.start();
        thread21.start();
    }
}
//下载器
class WebDownLoader
{
    public void downloader(String url,String name) {
        try {//从指定的地址复制文件到文件夹
                FileUtils.copyURLToFile(new URL(url), new File(name));
        }
        catch (IOException io)
        {
            io.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

实现Runnable接口，避免了单继承的局限性，方便同一个对象被多个线程使用

//实现Runnable接口，实现run()方法，编写线程执行体；创建线程对象，调用start()方法启动线程
public class RunnableTest implements Runnable{
    @Override
    //线程执行体
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程");
        }
    }
    public static void main(String[] args) {
    //创建实现类对象
        RunnableTest runnableTest=new RunnableTest();
        //创建代理类对象
        Thread thread=new Thread(runnableTest);
        thread.start();
    }
}

/龟兔赛跑
//首先来个赛道距离
//判断比赛是否结束
//打印出胜利者
//龟兔赛跑开始
//模拟兔子睡觉
//乌龟赢得比赛
public class GuiTu implements Runnable {
    private static  String winner;
    @Override
    public void run() {
        for (int i = 0; i <=100; i++) {
            //模拟兔子休息
            if(Thread.currentThread().getName().equals("兔子")&&(i%10==0))
            {
                try{
                    Thread.sleep(200);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            boolean isover=isGameOver(i);
            if (isover) {
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }
    //判断比赛是否结束
    public boolean isGameOver(int steps)
    {
        if (winner!=null) {
            return true;
        }
        else if (steps>=100){
            winner=Thread.currentThread().getName();
            System.out.println("胜利者是"+winner);
            return true;
        }
        else return false;
    }

    public static void main(String[] args) {
        GuiTu guiTu=new GuiTu();
        Thread thread=new Thread(guiTu,"兔子");
        Thread thread1=new Thread(guiTu,"乌龟");
        thread.start();
        thread1.start();

    }
}