java线程

最新推荐文章于 2024-07-27 17:56:15 发布

yx2003_0720

最新推荐文章于 2024-07-27 17:56:15 发布

阅读量89

点赞数

文章标签： java jvm servlet

本文链接：https://blog.csdn.net/yx2003_0720/article/details/126525747

版权

一.什么叫线程？

那我们要先了解什么叫进程，线程依赖于进程而存在的。
进程：正在运行的程序

是系统进行资源调用和资源分配的独立单位
每一个进程都有它自己的内存空间和系统资源

线程：是进程中的单个顺序控制流，是一条执行路径

单线程：一个进程如果只有一条执行路径就是单线程程序

记事本程序：在调出页面设置的时候只能在关闭页面设置之后进行其他操作，否则无法进行其他操作。

多线程：一个进程如果只有多条执行路径就是多线程程序

扫雷程序：点击第一下时间开始计时，时间计时的同时可以玩扫雷游戏

二.多线程的创建

方式一：继承Thread类

Java是通过java.lang.Thread 类来代表线程的。（不需要导包）
按照面向对象的思想，Thread类应该提供了实现多线程的方式。

方法：定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法

为啥要重写run（）方法：因为在MyThread里面还有其他的代码，并不是所有的代码都需要被线程执行，为了区分哪些被线程执行，java就提供了一个run（）方法

创建MyThread类的对象
调用线程对象的start()方法启动线程（启动后还是执行run方法的）

优缺点：

优点：编码简单

缺点：线程类已经继承Thread，无法继承其他类，不利于扩展。

/**
   目标：多线程的创建方式一：继承Thread类实现。
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        // 3、new一个新线程对象
        Thread t = new MyThread();
        // 4、调用start方法启动线程（执行的还是run方法）
        //run方法就是一个普通的方法，没有真正启动一个线程，就会把run方法执行完毕，才向下执行，
        //就是会先执行run方法 只有当run执行完毕才会执行其他线程
        t.start();
 
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出：" + i);
        }
 
    }
}
 
/**
   1、定义一个线程类继承Thread类
 */
class MyThread extends Thread{
    /**
       2、重写run方法，里面是定义线程以后要干啥
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

小问题：
为什么不直接调用了run方法，而是调用start启动线程。

直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。只有调用start方法才是启动一个新的线程执行。

方式二：实现Runnable接口

定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
创建MyRunnable任务对象
把MyRunnable任务对象交给Thread处理。
调用线程对象的start()方法启动线程

构造器	说明
public Thread(String name)	可以为当前线程指定名称
public Thread(Runnable target)	封装Runnable对象成为线程对象
public Thread(Runnable target ，String name )	封装Runnable对象成为线程对象，并指定线程名称

优缺点：

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

/**
   目标：学会线程的创建方式二，理解它的优缺点。
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        // 3、创建一个任务对象
        Runnable target = new MyRunnable();
        // 4、把任务对象交给Thread处理
        Thread t = new Thread(target);
        // Thread t = new Thread(target, "1号");
        // 5、启动线程
        t.start();
 
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}
 
/**
   1、定义一个线程任务类 实现Runnable接口
 */
class MyRunnable  implements Runnable {
    /**
       2、重写run方法，定义线程的执行任务的
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

方式三：JDK 5.0新增：实现Callable接口

1、前2种线程创建方式都存在一个问题：

他们重写的run方法均不能直接返回结果。不适合需要返回线程执行结果的业务场景。

2、怎么解决这个问题呢？

JDK 5.0提供了Callable和FutureTask来实现。这种方式的优点是：可以得到线程执行的结果。

3.多线程的实现方案三：利用Callable、FutureTask接口实现。

(1)、得到任务对象

定义类实现Callable接口，重写call方法，封装要做的事情。

用FutureTask把Callable对象封装成线程任务对象。

(2)、把线程任务对象交给Thread处理。

(3)、调用Thread的start方法启动线程，执行任务

(4)、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

优缺点：
优点：

线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

可以在线程执行完毕后去获取线程执行的结果。

缺点：

编码复杂一点。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
/**
   目标：学会线程的创建方式三：实现Callable接口，结合FutureTask完成。
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        // 3、创建Callable任务对象
        Callable<String> call = new MyCallable(100);
        // 4、把Callable任务对象 交给 FutureTask 对象
        //  FutureTask对象的作用1： 是Runnable的对象（实现了Runnable接口），可以交给Thread了
        //  FutureTask对象的作用2： 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        // 5、交给线程处理
        Thread t1 = new Thread(f1);
        // 6、启动线程
        t1.start();
 
 
        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();
 
        try {
            // 如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
            String rs1 = f1.get();
            System.out.println("第一个结果：" + rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        try {
            // 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
            String rs2 = f2.get();
            System.out.println("第二个结果：" + rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 
/**
    1、定义一个任务类 实现Callable接口  应该申明线程任务执行完毕后的结果的数据类型
 */
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }
 
    /**
       2、重写call方法（任务方法）
     */
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return "子线程执行的结果是：" + sum;
    }
}