Java——初识多线程

认识进程和线程

  • 进程指的一段正在运行的程序,一个程序运行中可以执行多个任务,任务称之为线程
  • 进程是程序执行过程中资源分配和管理的最小单位 线程是cpu执行的最小单位
  • 进程拥有自己的独立的地址空间,每启动一个线程,系统就会分配地址空间
  • 进程可以拥有多个线程,各个线程之间共享程序的内存空间

为什么出现线程

在多线程操作系统中,通常是在一个进程中包括多个线程,每个线程都是独立调度和分派的基本单位。资源由进程拥有,线程不拥有资源。同一个进程之间的线程切换不会导致进程的切换,只有不同进程间的线程切换才会导致进程切换。而且线程的切换则仅需保存和设置少量寄存器内容,不会同进程切换需求创建和销毁进程控制块等,所以非常迅速,所以其十分适合高并发环境。

多线程和多进程的区别

区别多进程多线程
地址空间独立的地址空间共享本进程的地址空间
资源拥有资源是独立的共享本进程的资源
导管进程崩溃后,不会对其他进程产生影响线程崩溃会影响整个进程
执行过程每个独立的进程程有一个程序运行的入口、顺序执行序列和程序入口线程不能独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制
单位进程是资源分配的最小单位线程是cpu调度的最小单位
创建/销毁开销
使用追求系统更加稳定,选择进程追求速度,频繁创建和销毁,选择线程
  • 线程之间的通信相比于进程之间的通信更有效 更容易
  • 多进程要比多线程健壮
  • 线程是轻量级的进程

线程的创建

1. 继承Thread类,重写run()方法

class MyThread extends Thread {
    @Override
    public void run(){
        //线程执行体
        while (true){
            System.out.println("吃饭");
        }
    }
}

class MyThread1 extends Thread {
    @Override
    public void run(){
        //线程执行体
        while (true){
            System.out.println("玩手机");
        }
    }
}

public class TestThread {
    public static void main(String[] args) {
        //创建线程对象
        Thread thread = new MyThread();
        Thread thread1 = new MyThread1();
        //启动线程
        thread.start();
        thread1.start();
    }
}

2. 实现Runnable接口,重写run()方法

class MyThread implements Runnable {
    @Override
    public void run(){
        //线程执行体
        while (true){
            System.out.println("吃饭");
        }
    }
}

class MyThread1 implements Runnable{
    @Override
    public void run(){
        //线程执行体
        while (true){
            System.out.println("玩手机");
        }
    }
}

public class TestThread {
    public static void main(String[] args) {
        //创建线程对象
        Thread thread = new Thread(new MyThread());
        Thread thread1 = new Thread(new MyThread1());
        //启动线程
        thread.start();
        thread1.start();
    }
}

3. 实现Callable接口,重写call()方法

Callable接口存在Executor框架中类,相比于Runnable更加强大
a.Callable可以在任务执行结束之后提供一个返回值
b.call方法可以抛出异常
c.运行Callable任务可以拿到一个Future对象,Future提供get方法
d.拿到返回值(异步)

  • 通过Callable和FutureTask创建线程:
    a.创建Callable接口的实现类,重写call方法
    b.创建Callable实现类的实例,使用FutureTask包装该实例
    c.将FutureTask实例作为参数创建线程对象
    d.启动该线程
    e.调用FutureTask的get方法获取子线程的执行结果
public class TestThread {
    public static void main(String[] args) {
        //2.创建Callable实现类的实例,使用FutureTask包装该实例
        Callable<Integer> callableTask = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(callableTask);
        //3.将FutureTask实例作为参数创建线程对象
        Thread thread = new Thread(task);
        //4.启动该线程
        thread.start();
        //5.调用FutureTask的get方法获取子线程的执行结果
        try {
            Integer integer = task.get();
            System.out.println("result: "+integer);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

Runnable接口和Callable接口的区别

区别RunnableCallable
函数返回值run()无返回值call()有返回值,支持泛型
异常处理run()只能抛出运行时异常,且无法捕获处理call()允许抛出异常,可以获取异常信息

小练习:12306卖车票

public class Web12306 implements Runnable{
    //票数
    private int ticketNums = 99;

    @Override
    public void run(){
        while (ticketNums > 0){
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+ticketNums--);
        }
    }

    public static void main(String[] args) {
        //一份资源
        Web12306 web12306 = new Web12306();
        System.out.println(Thread.currentThread().getName());
        //多个代理
        new Thread(web12306,"码农").start();
        new Thread(web12306,"码畜").start();
        new Thread(web12306,"蚂蟥").start();
    }
}
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页