华杉研发九学习日记23 多线程

华杉研发九学习日记23

java多线程

一， 线程

1.1 进程

进程就是一个程序运行的标志，是程序运行的状态。

一个正在运行的程序就是一个进程。进程是操作系统资源分配（计算资源，比如CPU，存储:内存）的最小单位。

多进程是并发执行。

在某个特定的CPU时间片中，只运行一个程序。而操作系统控制CPU，让多个程序不停的切换，从而保证多个程序能够轮流使用CPU

这就是单CPU执行多任务的原理:利用很短的CPU时间片运行程序，在多个程序之间进行CPU 时间片的进行快速切换。可以把这种运行方式总结成为一句话:宏观上并行，微观上串行。

从宏观上来看，一个系统同时运行多个程序，这些程序是并行执行的;

而从微观上说，每个时刻都只有一个程序在运行，这些程序是串行执行的。

1.2 线程

每一个程序独有很多独立的流程(功能),每一个流程就是线程。一个进程可以包含多个线程。
多个线程是相互独立，不影响的。

多线程并发执行。
多个线程在同步执行时，是以抢占式模式获取CPU的时间片来执行当前的线程。

1.3 并行和并发

并行就是在同一时刻同步执行。

并发就是在同一时间段同步执行。

1.4 单线程

如果一个进程，只有一个线程，这样的程序叫做单线程程序。

好处:资源可以最大化使用。不会出现争夺资源的问题。
缺陷:效率很低，容易阻塞。无法处理并发任务（例如:多人聊天)。

当你程序启动的时候，JVM会创建一个线程执行你的main函数，这个线程称为主线程。

1.5 多线程

如果一个进程,拥有不止一个线程。这样的程序称为多线程程序。

优势:可以同时执行多个任务。提高运行的效率。

二，java中实现多线程方式

1.继承Thread类，重写run方法

2.实现Runnable接口，实现接口中的run方法，让Runnable接口的实现类的实例对象作为Thread构造函数的target

3.通过线程池创建线程

4.实现Callable接口,实现接口中的call方法.把Callable接口的实现类对象,作为线程池的任务

2.1 使用Thread的子类

步骤:

1.创建一个子类，继承Thread类

2.重写其中的run方法(run方法定义的线程的任务)

3.创建子类对象，调用其中的start方法来启动线程(start方法是启动线程)

//  1.继承Thread类
public class Th1 extends Thread {
    //  2.重写其中的run方法
    //  线程的任务
    @Override
    public void run() {
        //  为了测试，直接使用for循环打印语句
        for(int i=1;i<=100;i++){
            System.out.println("线程1===="+i);
        }
    }
}

public class Th2 extends Th1 {
    @Override
    public void run(){
        for(int i=1;i<=100;i++){
            System.out.println("线程2--------"+i);
        }
    }
}

public class TestThread {
    public static void main(String[] args) {
        //  3.创建对象，调用start方法来启动线程
        Th1 t1 = new Th1();
        t1.start(); //  该方法一旦运行，底层会直接开启线程并调用run方法执行其任务

        Th2 t2 = new Th2();
        t2.start();
    }
}

2.2 实现Runnable接口

1.创建一个子类,实现Runnable接口

2.重写其中的run方法

3.创建子类对象

4.使用Thread来创建线程对象，同时把子类对象作为任务传入进去，调用start启动线程

public class Run1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("--------------"+i);
        }
    }
}

public class Run2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("========="+i);
        }
    }
}

public class TestRun {
    public static void main(String[] args) {
        //  创建对象
        Run1 run1 = new Run1();
        //  把任务对象包裹到线程中
        new Thread(run1).start();
        Run2 run2 = new Run2();
        new Thread(run2).start();
    }
}

2.3 匿名内部类实现

//  匿名内部类实现Thread
new Thread(new Runnable() {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("----------"+i);
        }
    }
}).start();
new Thread(new Runnable() {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("======"+i);
        }
    }
}).start();
Runnable runnable = ()->{
    for (int i = 0; i < 100; i++) {
        System.out.println("+++"+i);
    }
};
new Thread(runnable).start();

2.4 多线程拷贝

单线程拷贝:之前的视频拷贝都是一个视频一个视频的拷贝，只有上个视频拷贝完成，才能开启下个视频的拷贝

多线程拷贝:就是有多少个视频，每一个视频都单独开启一个线程进行读写操作

public static void copy(File from, File to){
    Runnable runnable=()->{
        try (
                //  创建对象
                BufferedInputStream br = new BufferedInputStream(new FileInputStream(from));
                BufferedOutputStream bw = new BufferedOutputStream(new FileOutputStream(to))
        ) {
            //  拷贝
            byte[] buf = new byte[1024];
            int len;
            while ((len = br.read(buf)) != -1) {
                bw.write(buf, 0, len);
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    };
    new Thread(runnable).start();

}

public static void main(String[] args) {
    File file = new File("C:\\Users\\86155\\Videos\\Counter-strike 2");
    File[] files = file.listFiles();
    for(File f : files){
        copy(f, new File("C:\\Users\\aa", f.getName()));
    }
}

三，多线程的常用方法

currentThread()获取当前线程对象。

类方法setName(String name)设置线程的名字。

getName()获取线程的名字。
如果没有设置名称，则默认名称为: Thread-N

setPriority(int priority)设置线程的优先级。优先级的取值范围[1,10].默认是5

getPriority()获取线程的优先级。

getState()获取线程的状态

join()执行该线程，会阻塞当前线程，直到该线程执行完成，当前线程才可以执行。【让行】

sleep(long millis)休眠指定时间（单位毫秒)，会阻塞当前线程。类方法

start()启动线程

yield()暂停该线程的执行，交出CPU的使用权。

public static void main(String[] args) {
    Thread1 t1 =new Thread1("");
    t1.setName("窗口一");
    t1.setPriority(10);
    t1.start();
    Thread1 t2 =new Thread1("");
    t2.setName("窗口二");
    t2.setPriority(1);
    t2.start();
    Run run = new Run();
    Thread thread = new Thread(run,"小孤鸡");
    thread.start();
}

public class Thread1 extends Thread {
    String name;
    public Thread1(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "-----" + i+"--"+getPriority());
        }
    }
}

四，线程的状态及生命周期