Java多线程小结

多线程的概念

什么是多线程?

多线程可以将它拆开理解,指很多个线程组成的

线程是操作系统能够进行运算调度的最小单位,它包含在进程之中

进程

进程可以理解成一个软件代表一个进程,例如任务管理器中就可以查看到我们电脑的进程,可以看得到每一个软件应用就代表一个进程

线程

• 进程想要执行任务就需要依赖线程
• 进程中的最小执行单位就是线程

举例电脑管家这一应用进程 :  将每一个功能理解为对应的每个线程

• 病毒查杀
• 体验
• 垃圾清理等

多线程的实现方式

多线程有三种实现方式:

1. 继承Thread类的方式进行实现
2. 实现Runnable接口的方式
3. 利用Callable接口和Future接口方式实现

继承Thread类

1. 自己定义一个类去继承Thread
2. 去重写run方法

public class MyThread extends Thread{
    @Overrride
    public void run(){
        for (int i = 0; i < 50; i++){
            System.out.println(getName()+"helloword")
        }
    }
}

      3.创建子类的对象,启动线程

public static void main (String[] args){
    //创建子类的对象
    MyThread t1 = new MyThread();
    MyThread t2 = new MyThread();
    //给线程设置名字
    t1.setName("1线程")
    t2.setName("2线程")
    //启动线程
    t1.start();
    t2.start();
}

实现Runnable接口

1. 自己定义一个类去实现Runnable接口
2. 去重写里面的run方法

public class MyThread implements Runnable{
    @Overrride
    public void run(){
        for (int i = 0; i < 50; i++){
        //获取到当前线程的对象
        Thread t = Thread.currentThread();
        System.out.println(t.getName()+"helloword")
        }
    }
}

     3.创建自己的类的对象

     4.创建一个Thread类的对象,并启动线程

public static void main (String[] args){
    //创建子类的对象
    MyThread m = new MyThread();
    //创建线程对象
    Thread t1 = new Thread(m);
    Thread t2 = new Thread(m);
    //给线程设置名字
    t1.setName("1线程")
    t2.setName("2线程")
    //启动线程
    t1.start();
    t2.start();
}

实现Callable 接口和Future接口方式

1. 创建一个类实现Callable接口
2. 重写call (是有返回值的,表示多线程的运行的结果)

public class MyThread implements Callable<Integer>{
    @Overrride
    public Integer call() throws Exception{
        //求1~100之间的和
        int sum = 0;
        for (int i = 0; i <= 100; i++){
            sum = sum + i;
        }
        return sum;
    }
}

     3.创建自己的类的对象(表示多线程要执行的任务)

     4.创建一个FutureTask的对象(作用管理多线程运行的结果)

     5.创建Thread类的对象,并启动线程(表示线程)

public static void main (String[] args){
    //创建子类的对象
    MyThread m = new MyThread();
    //创建FutureTask对象
    FutureTask<Integer> ft = new FutureTask<>(m);
    //创建线程对象    
    Thread t1 = new Thread(ft);
    //启动线程
    t1.start();
    //获取多线程运行的结果
    Integer result = ft.get();
    System.out.println(result);
}

tips : 因为我们实现的是接口,不能直接调用他的构造方法,需要创建Thread的类的对象,再获取当前线程的对象才能,再通过对象调用构造方法

创建线程的三种方式的对比

• 1. 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。

• 2. 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

小结

• 有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如：程序中有两个子系统需要并发执行，这时候就需要利用多线程编程。

• 通过对多线程的使用，可以编写出非常高效的程序。不过请注意，如果你创建太多的线程，程序执行的效率实际上是降低了，而不是提升了。