一个 进程(Process) 可以有多个 线程( Thread ) ，例如视频中同时出现声音、图像、弹幕等，可以理解视频进程包含了处理声音的线程a、处理图像的线程b、处理文字的线程c。进程和线程就是这么一种关系

单线程 和 多线程 比较：

一般的程序，执行到函数run(),原本的线程 暂停 转到run（）执行，run()执行完后，再回来继续执行原来的线程

那如果子线程run（）和主线程可以 同时执行 ，效率就会大大提高。

• 程序 是指令和数据的集合，是一个静态的概念。

• 进程 是程序的一次执行过程，它是动态的概念。是系统分配资源的单位。
• 一个进程 可以包含 若干个线程 ，至少有一个线程。线程是CPU调度和执行的单位（这属于操作系统部分的知识）。
• 线程 就是程序中独立执行的一条路径。

当然，平时的多线程很多是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。 模拟 出来的 多线程 ，因为只有一个CPU，实际上CPU在执行程序时，同一时间只能执行一个线程，但是因为执行的 线程切换 得很快，所以看起来就像多个线程 同时执行 一样。（操作系统：并发和并行的概念）

线程创建

• 方式1.继承Thread类
• 方式2.实现Runnable接口
• 方式3.实现Callable接口

方式1

 //继承Thread类，重写run()方法，调用start启动线程
public class TestThread1 extends Thread{
    @ Override 
    public synchronized void start() {
        super.start();
    }

    @Override
    public void run() {
        //重写run
        for(int i = 0;i < 50; i++){
             System .out.println("执行了run函数");
        }
    }
    public static void main(String[] args){
        //创建一个线程
        TestThread1 testThread1 = new TestThread1();
        //启动线程
        testThread1.start();

        for(int i = 0;i < 50; i++){
            System.out.println("主线程");
        }
    }
}  

结果发现，两个线程是交替执行的，这就是模拟的多线程：

demo ：多线程下载图片

下载commonsIO包，百度commonsIO包

下载后解压把里面的jar包复制到项目文件夹下，新建个lib用来存放jar包，但是还不能用，右键lib，选择Add as liberary，就可以看到下拉菜单

写代码，方式1-继承Thread类实现多线程功能：

 package thread;
import org.apache.commons.io.FileUtils;

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

public class TestThread2 extends Thread{
    private String url;//网络图片地址
    private String name;//保存的文件名

    //重写构造器
    public TestThread2(String url, String name){
        this.url = url;
        this.name = name;
    }
//重写run方法
    @Override
    public void run() {
        WebDownloader webdownloader = new WebDownloader();
       //调用下载器
        webdownloader.downloader(url, name);
        System.out.println("下载了图片文件名为："+name);

    }
    //主程序入口
    public static void main(String[] args){
      //从网络找图片，复制图片地址
        String url1 = " jpg ";
        String url2 = "#34;;
        String url3 = "#34;;
        //创建线程
        TestThread2 t1 = new TestThread2(url1,"1.jpg");
        TestThread2 t2 = new TestThread2(url2,"2.jpg");
        TestThread2 t3 = new TestThread2(url3,"3.jpg");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}


//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url, String name){
        try {
            //args:url,file
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}  

下载完成，同样看到线程执行顺序不同于代码编写的顺序，这是系统调度器安排的线程执行顺序。

方式2：实现 Runable接口 来实现多线程（常用）：

 //创建线程方式2：实现Runnale接口，重写run方法，调用start方法
public class TestThread3 implements Runnable{
    @Override
    public void run() {
        //重写run
        for(int i = 0;i < 50; i++){
            System.out.println("执行了run函数");
        }
    }
    public static void main(String[] args){
        //创建Runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        //通过一个Thread，把Runnable接口的实现类testThread3丢进去，来调用start
        Thread thread = new Thread(testThread3);

        //启动线程
        thread.start();

        for(int i = 0;i < 50; i++){
            System.out.println("主线程");
        }
    }
}  

把下载图片的程序改成方式2，只要两步：

 //一、实现接口 ：implements Runnable
public class TestThread2_1 implements Runnable{...}

//二、启动线程，new Thread，把实现类的对象丢进去，通过Thread调用start（）方法
//t1.start();
new Thread(t1).start();
//t2.start();
new Thread(t2).start();
//t3.start();
new Thread(t3).start();   

对比：

继承Thread类

• 子类继承Thread类，实现多线程
• 启动线程：子类对象.start()
• 不推荐，避免OOP单继承局限性

实现Runnable接口：

• 实现接口Runnable接口，实现多线程
• 启动线程：传入目标对象->new Thread对象.start()->
• 推荐使用：灵活方便，方便同一个对象被多个线程使用

实例 ：买票问题，多个线程同时操作同一个对象。

 
public class TestThread4 implements Runnable{
    private  int ticketNums = 10;

    @Override
    public void run() {
        while(true){
            if(ticketNums<=0){
                 break ;
            }
            try {//模拟延时，举例发现多线程的问题
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //获取当前线程的名字name
            System.out.println(Thread.currentThread().getName()+" 拿到了第 "+ticketNums+" 张票");
            //减去一张票
            ticketNums --;
        }
    }
    public static void main(String[] args){
        //接口实现类对象
        TestThread4 testThread4 = new TestThread4();
        //传入接口实现类对象，通过Thread类调用start()
        new Thread(testThread4, "小明").start();
        new Thread(testThread4, "小光").start();
        new Thread(testThread4, "小黑").start();
    }
}  

结果看到，同一张票被多个人拿到，这显然不合理。

发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱。

多线程 demo ：龟兔赛跑

 //包名，自定义的，代码所在的文件夹名
package thread;

public class Race implements Runnable{
    private static String winner;
    //重写线程运行run方法
    @Override
    public void run() {
        //简单设置跑道100步远
        for(int i = 0;i<=100;i++){
            //比赛结束的标志-bool变量
            boolean flag = gameOver(i);
            //判断比赛是否结束
            if(flag){
                //结束，退出循环
                break;
            }
            //输出当前进程跑了多少步
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }

    //判断是否有人跑到100步，有则比赛结束
    public 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 race = new Race();
        //定义两个比赛者，start！
        new Thread(race,"乌龟").start();
        new Thread(race,"兔子").start();
    }
}
  

多运行几次，结果都不一样，因为调度器安排的执行顺序每次都不一样。