03 Java线程学习1

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

介绍

Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6Wf0bDCR-1593089275811)(C:\Users\Tangs\AppData\Roaming\Typora\typora-user-images\1593048108216.png)]

Process与Thread

程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

进程则是执行程序的一次执行过程，他是一个动态的概念。是系统资源分配的单位。

通常一个进程中可以包含若干个线程。线程是CPU调度和执行的基本单位。

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

线程创建

• Thread class 继承Thread类
• Runnable接口 实现Runnable接口
• Callable接口 实现Callable接口

Thread类

• 自定义线程类继承Thread类
• 重写**run()**方法，编写线程执行体
• 创建线程对象，调用**start()**方法启动线程

public class TestThread 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线程，主线程
        //创建一个线程对象
        TestThread testThread = new TestThread();
        
        //调用start()方法开启线程
        testThread.start();
        
        for(int i = 0; i < 20; i++){
            System.out.println("多线程执行"+i);
        }
    }
}

实例：线程同时下载图片

import org.apache.commons.io.FileUtils;

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

public class ThreadTest extends Thread {
    private String url; //图片下载路径
    private String name;    //图片名字

    public ThreadTest(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) {
        ThreadTest t1 = new ThreadTest("https://img-blog.csdn.net/20161120091317312", "1.jpg");
        ThreadTest t2 = new ThreadTest("https://img-blog.csdn.net/20161120091128267", "2.jpg");
        ThreadTest t3 = new ThreadTest("https://img-blog.csdn.net/20161120091439735", "3.jpg");

        t1.start();
        t2.start();
        t3.start();
    }
}

//下载器
class WebDownloader{
    //    下载方法
    public void downloader(String url, String name){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Runnable 接口

• 创建Runnable接口的实现类对象
• 创建线程对象，通过线程对象来开启我们的线程（代理模式）

public class TestThread implements Runnable{
    @Override
    public void run(){
        //run方法线程体
        for(int i = 0; i < 20; i++){
            System.out.println("我在看代码---"+i)；
        }
    }
    
    public static void main(String[] args){
        //main线程，主线程
        //创建runnable接口的实现类对象
        TestThread testThread = new TestThread();
        
        //创建线程对象，通过线程对象来开启我们的线程（代理）
        new Thread(testThread).start();
        
        for(int i = 0; i < 20; i++){
            System.out.println("多线程执行"+i);
        }
    }
}

继承Thread类与实现Runnable接口对比

继承Thread类

• 子类继承Thread类具备多线程能力
• 启动线程：子类对象.start();
• 不建议使用：避免OOP单继承局限性

实现Runnable接口

• 实现接口Runnable具有多线程能力
• 启动线程：传入目标对象+Thread对象.start();
• 推荐使用：避免单继承的局限性，方便灵活，方便同一对象被多个线程使用

注意：当同一资源被多个线程利用时，会出现错误。例如以下购买车票程序，多人购买到同一张车票

public class ThreadTest1 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();
            }
            System.out.println(Thread.currentThread().getName()+"获得了第"+ticketNums--+"张票");
        }
    }

    public static void main(String[] args) {
        ThreadTest1 threadTest1 = new ThreadTest1();

        new Thread(threadTest1, "小米").start();
        new Thread(threadTest1, "老师").start();
        new Thread(threadTest1, "黄牛").start();
    }
}

运行结果：

老师获得了第10张票
小米获得了第8张票
黄牛获得了第9张票
小米获得了第7张票
老师获得了第6张票
黄牛获得了第6张票
小米获得了第5张票
老师获得了第5张票
黄牛获得了第4张票
黄牛获得了第3张票
小米获得了第2张票
老师获得了第3张票
黄牛获得了第1张票
小米获得了第0张票
老师获得了第0张票

案例：龟兔赛跑

背景介绍：

1. 首先来个赛道距离，然后距离终点越来越近
2. 判断比赛是否结束
3. 打印出胜利者
4. 龟兔赛跑开始
5. 故事中是乌龟赢了，兔子需要睡觉，所以我们通过sleep模拟兔子睡觉
6. finally，乌龟赢得比赛

程序代码：

public class ThreadRace 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(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(i);
            //比赛有winner，退出跑步
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"米");
        }
    }

    //判断比赛是否完成
    private boolean gameOver(int steps){
        if (winner != null) {
            return true;
        }else{
            if (steps >= 100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is "+ winner);
                return true;
            }
        }
        return false;
    }

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

    }
}

Callable接口

1. 实现Callable接口，需要返回值类型
2. 重写call方法，需要抛出异常
3. 创建目标对象
4. 创建执行服务：ExecutorService service = Executors.newFixedThreadPool(3);
5. 提交执行：Future<Boolean> r1 = service.submit(t1);
6. 获取结果：boolean rs1 = r1.get();
7. 关闭服务：service.shutdown();