多线程

多线程

多线程概述

  • 多线程就是计算机用时运行多个任务
  • 但实质上,同一个时间点,只会运行一个任务,只是计算机在不同任务之间来回切换而已。
并发和并行

并行:在同一时间,多个任务分别在多个CPU上进行。

并发:在同一时间,多个任务在同一个CPU交替进行。

线程和进程

进程

  • 独立性:进程是一个独立运行的应用程序。
  • 动态性:进程就是一个程序运行的过程,程序开始运行,进程创建,运行接收,进程消亡。
  • 并发性:任何进程可以和其他进程并发执行。

线程不能单独存在,线程是进程的一部分,一个进程可以有多可线程,但必须至少有一个线程。

多线程实现

  1. 实现多线程方式一:继承Thread类,Thread类就是线程类,要实现多线程必须创建Thread类对象。

自定义类通过继承Thread类,再重写run() 方法

public class ThreadDemo extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"的第"+i+"次");
        }
    }
}

在测试类中创建自定义类对象

public class TestDemo {
    public static void main(String[] args) {
        ThreadDemo t1 = new ThreadDemo();
        //为线程设置名字
        t1.setName("线程1");
        //start() 方法告诉JVM程序会启用多线程,并自动调用run() 方法
        //直接执行run() 方法,那么就是执行一个普通的单线程方法
        t1.start();

        ThreadDemo t2 = new ThreadDemo();
        t2.setName("线程2");
        t2.start();
    }
}
  1. 实现多线程方式二:实现Runnable接口
public class RunnableDemo implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //让线程停止指定毫秒数
            //父类Thread没有抛出异常,所以子类只能自己捕获异常
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //调用Thread的静态方法currentThread(),可以直接获取当前的进程
            System.out.println("这是线程"+Thread.currentThread().getName()+i);
        }
    }
}

测试类

public class TestDemo2 {
    public static void main(String[] args) {
        RunnableDemo ra = new RunnableDemo();

        //调用Thread() 的带参方法,传入一个Runnable的实现类对象
        Thread thread = new Thread(ra);
        thread.setName("西安");
        //为该线程设置优先级1(min)-10(max),优先级越高,抢占CPU的几率就越大,但不会达到100%
        thread.setPriority(10);
        //获取优先级
        System.out.println(thread.getPriority());
        thread.start();
        
        Thread thread2 = new Thread(ra);
        thread2.setPriority(1);
        //获取优先级
        System.out.println(thread2.getPriority());
        thread2.setName("杭州");
        thread2.start();
    }
}
  1. 实现Callable接口
public class CallableDemo implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("和班主任请假第"+i+"次");
        }
        return "同意";
    }
}

测试类

public class TestDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableDemo cd = new CallableDemo();
        FutureTask<String> ft = new FutureTask<>(cd);
        Thread thread = new Thread(ft);
        thread.start();
        FutureTask<String> ft2 = new FutureTask<>(cd);
        Thread thread2 = new Thread(ft2);
        thread2.start();
        //注意如果在start方法之前 调用get() 方法,意味着在开启线程之前获取返回值,但是此时线程尚未开启,这就照成死锁
        String o = ft.get();
        String o2 = ft2.get();
        System.out.println(o);
        System.out.println(o2);
    }
}
总结如下:
  • 方式一:通过自定义类继承Thread的方式。

优点:子类可以直接调用父类的方法,缺点,对子类限制比较大,不能再继承其他类

  • 方式二 :通过自定义类实现Runnable接口的方式。

优点:通过实现接口的方式,子类还可以继承其他类,拓展性更强

缺点:不能直接启用多线程,需要先创建Runnable实现类对象,再使用Thread的带参构造传入Runnable实现类对象,再通过Thread对象启用多线程

  • 方式三:通过自定义类实现Callable接口的方式

优点:通过实现接口的方式,子类还可以继承其他类,执行线程后还可以返回值

缺点:不能直接启用多线程,需要先需要先创建Callable实现类对象,再使用FutureTask的带参构造传入Runnable实现类对象,再使用Thread的带参构造传入FutureTask类对象,再通过Thread对象启用多线程

守护线程

守护线程会因为普通线程结束而结束,无论守护线程是否执行完毕

代码如下:

public class DaemonDemo {
    public static void main(String[] args) {
        Test1 t1 = new Test1();
        t1.setName("主人");
        t1.setPriority(1);
        t1.start();
        
        Test2 t2 = new Test2();
        t2.setDaemon(true);
        t2.setName("保镖");
        t2.setPriority(10);
        t2.start();
    }
}
/**
 * 主人线程
 */
public class Test1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"..."+i);
        }
    }
}
/**
 * 保镖线程
 */
public class Test2 extends Thread{
    @Override
    public void run() {
        try {
            Thread.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"==="+i);
        }
    }
}

热门相关:斗神战帝   霸皇纪   仗剑高歌   寂静王冠   仗剑高歌