Java多线程（一）

要向着光

于 2022-11-21 20:11:27 发布

阅读量381

点赞数

分类专栏： Java学习文章标签： java 开发语言 intellij idea

本文链接：https://blog.csdn.net/zssxcj/article/details/127962025

版权

Java学习专栏收录该内容

41 篇文章 2 订阅

订阅专栏

比较创建线程的继承方式和实现Runnable接口方式

继承方式和实现Runnable接口方式的联系与区别

JDK5.0新增线程创建方式

创建线程方式三：实现Callable接口

实现Callable接口创建线程方式的练习

如何理解实现Callable接口创建多线程的方式比实现Runnable接口创建多线程的方式强大？

创建线程方式四：使用线程池

使用线程池创建多线程方式练习

一、基本概念

程序、进程、线程

程序：程序是为了完成特定任务、用某种语言编写的一组指令集合。即一段静态的代码，静态对象。

进程：进程是程序的一次执行过程，或是正在运行的一段程序。是一个动态的过程，有它自身的产生、存在和消亡的过程（生命周期）。

说明：

1、程序是静态的，进程是动态的。

2、进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。

若一个进程同一时间并行执行多个线程，就是支持多线程的
线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc）,线程切换的开销小
一个进程中的多个线程共享相同的内存单元/内存地址空间-->它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程更加简便、高效。但多个线程操作共享的系统资源可能会带来线程安全问题

单核CPU和多核CPU

单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。但是因为CPU时间单元特别短，因此感觉不出来。

如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）

一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

使用多线程的优点

1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

2. 提高计算机系统CPU的利用率

3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

二、线程的创建与使用

线程的创建和启动

Java语言的JVM允许多个线程同时运行，它通过java.lang.Thread类来体现

Thread类

Thread类的特性

1.每个线程都是通过某个特定的Thread对象的run()来完成的，经常把run()的主体称为线程体

2.通过该线程对象的start()来启动这个线程，而非直接调用run()

Thread类的构造器

Thread()：创建新的Thread对象
Thread(String threadname)：创建线程并指定线程实例名
Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Thread(Runnable target, String name)：创建新的Thread对象

API中创建线程的两种方式

JDK1.5之前创建新执行的线程有两种方式：

继承Thread类
实现Runnable接口的方式

创建线程方式一：继承Thread类

创建线程步骤：

1）定义子类继承于Thread类

2）子类中重写Thread类中的run()方法------>将执行线程的操作声明在run()中

3）创建Thread类的子类对象

4）通过此对象调用start()方法

注意点：

1、如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。

2、run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU 调度决定。

3、想要启动多线程，必须调用start()方法。

4、一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出异常：“IllegalThreadStateException”。

5、如果想要在创建一个线程，应重新创建一个线程对象

创建继承Thread类线程方式练习

创建一个分线程，打印输出1-20以内偶数；主线程中输出1-20以内奇数

public class ThreadTest1 {
    public static void main(String[] args) {
//        3、创建Tread类的子类对象
        myThread p1=new myThread();
//        4、通过此对象调用start():①启动当前线程②调用当前线程的run()方法
        p1.start();
        //如下操作依旧在main线程中操作
        for(int i=0;i<=20;i++){
            if(i%2!=0){
                System.out.println(i+"'*******main()*******");
            }
        }
    }
}

//创建Thread类的子类对象

//1、继承于Thread子类
class myThread extends Thread {
    //2、重写Thread类中的run()方法
    public void run(){
        for(int i=0;i<20;i++){
            if(i%2==0){
                System.out.println(i);
            }
        }
    }
    
 }

运行结果如下：

创建线程方式二：实现Runnable接口

创建线程步骤：

1）定义实现类实现Runnable接口

2）子类中重写Runnable接口中的抽象方法：run()-------->将线程执行的操作声明在run()中

3）创建实现类的对象

4）将实现类的对象作为参数传递到Thread类的构造器中，并创建Thread类对象

5）通过Thread类的对象调用start()方法

创建实现Runnable接口线程方式练习

创建一个分线程，打印输出1-20以内偶数；主线程中输出1-20以内奇数

//1、创建一个实现了Runnable接口的类
class MThread implements Runnable{
   //2、实现类的Runnable接口的抽象方法：run()
    @Override
    public void run() {
        for(int i=0;i<=20;i++){
            if (i%2==0){
                System.out.println(i);
            }

        }
    }
}

public class ThreadTest2 {
    public static void main(String[] args) {
        //3、创建实现类的对象
        MThread mThread=new MThread();
        //4、将此对象作为参数传递到Thread类的构造其中，创建Thread类的对象
        //5、通过Thread类的对象调用start()方法:①启动线程 ②调用当前线程的run()-->调用了Runnable类的target的run()
        new Thread(mThread).start();
        //主线程
        for(int i=0;i<=20;i++){
            if (i%2!=0){
                System.out.println(i+"************main()***********");
            }

        }

    }
}

运行结果为：

比较创建线程的继承方式和实现Runnable接口方式

开发中优先选择实现Runnable接口的方式

实现Runnable接口方式的好处：

1、实现Runnable接口方式的方式没有类的单继承性的约束

2、多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

继承方式和实现Runnable接口方式的联系与区别

区别：

继承Thread类：线程代码存放在Thread子类的run()中
实现Runnable：线程代码存放在接口的子类的run()中

联系：

Thread类本身也实现了Runnable接口
两种方式都重写了run()，将线程要执行的操作声明在run()中

JDK5.0新增线程创建方式

创建线程方式三：实现Callable接口

创建线程步骤：

1）创建一个Callable接口的实现类

2）重写Callable接口的抽象方法：call()------->将此线程操作声明在call()中（该方法有返回值）

3）创建Callable接口的实现类的对象

4）将此Callable接口的实现类的对象作为参数传递到FutureTask类的构造其中，并创建FutureTask类的对象

5）将FutureTask类的对象作为参数传递到Thread类的构造器中，并创建Thread类的对象

6）调用创建好的Thread类的对象的start()方法

7）可以获取call()的返回值（按需选择）

实现Callable接口创建线程方式的练习

创建一个线程打印1-20以内偶数，并求和，返回求和值

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadNew1 {
    public static void main(String[] args) {
//        3、创建Callable接口实现类的对象
        NumThread numThread=new NumThread();
//        4、将此Callable接口实现类的对象作为参数传给FutureTask构造器中，创建FutureTask类对象
        FutureTask futureTask = new FutureTask(numThread);
//        5、将创建好的FutureTask对象作为参数传递给Thread构造其中，创建Thread类对象
        Thread thread = new Thread(futureTask);
//        并调用该类对象的start()
        thread.start();
        try {
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }
}

// 1、创建一个实现Callable接口的实现类
class NumThread implements Callable{
//    2、实现call()，将此线程需要执行的操作声明在call()中；call()可以有返回值
    @Override
    public Object call() throws Exception {
        int sum=0;
        for(int i=1;i<=20;i++){
            if(i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;//存在自动装箱
    }
}

运行结果如下：

如何理解实现Callable接口创建多线程的方式比实现Runnable接口创建多线程的方式强大？

1）相比run()方法，call()方法有返回值

2）call()方法可以抛出异常

3）支持泛型的返回值

4）需要借助FutureTask类，比如获取返回结果

Future接口：

可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。

FutrueTask是Futrue接口的唯一的实现类

FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行，又可以作为Future得到Callable的返回值

创建线程方式四：使用线程池

创建线程步骤：

1）创建一个指定数量的线程池

2）执行指定的线程操作。需要提供实现Runnable接口或Callable接口实现类的对象

3）关闭线程池

线程池相关API：

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行 Runnable
Future submit(Callable task)：执行任务，有返回值，一般又来执行 Callable
void shutdown() ：关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

使用线程池创建多线程方式练习

使用线程池创建线程，一个线程打印输出1-20以内偶数，一个线程打印输出1-20以内奇数

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadNew2 {
    public static void main(String[] args) {
//        1、提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

//        2、执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适用于Runnable

        Future future = service.submit(new NumberThread1());//适用于Callable接口
//        3、关闭连接池
        service.shutdown();
    }
}
class NumberThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <=20; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+"："+i);
            }
        }
    }
}
class NumberThread1 implements Callable{
    @Override
    public Object call() throws Exception {
        for (int i = 0; i <=20; i++) {
            if(i%2!=0){
                System.out.println(Thread.currentThread().getName()+"："+i);
            }
        }
        return null;
    }
}

运行结果：

要向着光

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java多线程（一）

程序：程序是为了完成特定任务、用某种语言编写的一组指令集合。即一段静态的代码，静态对象。进程：进程是程序的一次执行过程，或是正在运行的一段程序。是一个动态的过程，有它自身的产生、存在和消亡的过程（生命周期）。说明：1、程序是静态的，进程是动态的。2、进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。每个线程拥有独立的运行栈和程序计数器（pc）
复制链接

扫一扫

专栏目录