多线程总结——1

程序、线程、进程

程序跑起来变成了进程，进程里面又有若干个线程
main（）函数就是主线程

• 程序：program 静态的代码。
• 进程：process 跑起来的代码（运行起来的程序）是动态的。
• 线程：thread 一个进程里面有若干个线程，独立的代码执行路径

一个进程里面至少有两个线程

• main（）——主线程
• gc（）——垃圾回收器线程
  main线程结束gc线程也就结束了

核心概念

• 线程是独立的执行路径
• 程序运行即使没有自己去创建线程，后台也会存在main线程和gc线程
• main主线程，入口，执行整个系统
• CPU同一时间只能运行一个线程，线程调度由CPU执行，执行顺序不能人为干预
• 同一个资源存在资源抢夺，需要加入并发控制
  例如：抢鞋，排队，否则鞋的数量就成了负数了
• 多个线程就会带来额外的开销，例如：CPU调度所需要的时间，以及并发控制所需要的时间和资源
• 每个线程会在自己的内存空间进行交互，内存控制不当会使得数据发生错误。
  例如：多个人去操作一个银行账户，内存控制不当会使得账户余额发生错误，造成不必要的损失

传统方法和多线程比较

传统方法：new 一个类的对象，去调用run（）方法，只有主线程一个按照顺序依次执行
多线程：new 一个类的对象，去调用start（）方法，启动子线程。多条执行路径，子线程与主线程交替执行（并行）。

线程创建方式

继承Thread类

package com.Thread.demo01;
/*
线程的实现：
    继承Thread类
    1.定义一个类继承Thread类
    2.重写run()方法，编写线程的执行体
    3.创建线程对象调用start()方法来启动线程
 */
public class TestThread01 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println("run()"+i);
        }
    }

    public static void main(String[] args) {
        TestThread01 testThread01 = new TestThread01();
        testThread01.start();
        for (int i = 0; i <1000 ; i++) {
            System.out.println("main()"+i);
        }
    }
}

运行结果：

线程不一定立即执行，由CPU安排调度，因为CPU的调度需要时间

Runnable 接口

实现Runnable接口

package com.Thread.demo01;

/*实现线程的第二种方法：
实现 Runnable接口
重写run（）方法
定义线程体
new一个   接口runnable的实现类的对象
创建线程对象，通过此来进行代理（静态代理）
 */
public class TestThread03 implements Runnable{
    @Override
    //重写run（）方法
    public void run() {
//        定义线程体
        for (int i = 0; i <200 ; i++) {
            System.out.println("run()"+i);
        }
    }

    public static void main(String[] args) {
//        new一个   接口runnable的实现类的对象
        TestThread01 testThread03 = new TestThread01();
        new Thread(testThread03).start();

        for (int i = 0; i <3000 ; i++) {
            System.out.println("main()"+i);
        }
    }
}

比较继承Thread和实现Runnable

继承Thread类

子类继承父类，单继承，有局限性，不建议使用
启动：子类对象.start（）

TestThread01 testThread01 = new TestThread01();
        testThread01.start();

实现Runnable接口

避免单继承，更加灵活，方便一个对象被多个线程使用
启动：

//        new一个   接口runnable的实现类的对象
        TestThread01 testThread03 = new TestThread01();
        new Thread(testThread03).start();

并发问题

多个线程同时操作一个资源的时候，数据紊乱，线程不安全

package com.Thread.demo01;

public class TestThread04 implements Runnable{
    //模拟抢票
    private int ticketNum=10;

    @Override
    public void run() {
        while (true){
            if (ticketNum<=0){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNum--+"张票");
        }
    }

    public static void main(String[] args) {
        TestThread04 testThread04 = new TestThread04();
        new Thread(testThread04,"DJ").start();
        new Thread(testThread04,"AI").start();
        new Thread(testThread04,"鞋贩子").start();
    }
}

结果：

实现Callable接口

优点：

• 可以定义返回值

• 可以抛出异常

实现步骤：

1. 实现Callable接口，需要有返回值类型
2. 重写call()方法
3. 创建接口的实现类的对象
4. 创建执行服务
5. 提交执行
6. 获取结果
7. 关闭服务

package com.Thread.demo02;


import org.apache.commons.io.FileUtils;

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

public class TestCallable implements Callable <Boolean> {
    private String url;
    private String name;
    public TestCallable(String url,String name){
        this.url=url;
        this.name=name;
    }
    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.download(url,name);
        System.out.println("下载了文件名为："+name+"的图片");
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建目标对象
        TestCallable t1 = new TestCallable("https://ss2.bdstatic.com/70cFvnSh_Q1YnxGkpoWK1HF6hhy/it/u=1829620569,2619159381&fm=15&gp=0.jpg","1.jpg");
        TestCallable t2 = new TestCallable("https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=3430276162,2886253048&fm=26&gp=0.jpg","2.jpg");
        TestCallable t3 = new TestCallable("https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=3430276162,2886253048&fm=29&gp=0.jpg","3.jpg");
        //创建执行服务                   固定长度线程池      长度为： 3
        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);
        System.out.println(rs2);
        System.out.println(rs3);
        //关闭服务
        ser.shutdownNow();

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