线程简介及创建代码

最新推荐文章于 2023-02-10 20:29:32 发布

zzcheng_gogo

最新推荐文章于 2023-02-10 20:29:32 发布

阅读量242

点赞数

分类专栏： # 多线程文章标签：多线程

本文链接：https://blog.csdn.net/zzcheng_gogo/article/details/106780592

版权

多线程专栏收录该内容

8 篇文章 0 订阅

订阅专栏

线程

1.什么是线程、多线程

线程(thread)：操作系统进行运算调度的最小单位。是进程中的实际运作单位，一个进程可以有很多线程，每条线程并行执行不同的任务。
多线程(multithreading):从软件或者硬件上实现多个线程并发执行的技术。同一时间执行多个线程，提升整体处理性能
多线程作用：为了同步完成多项任务，不是为了提高运行效率，而是为了提高资源使用效率来提高系统的效率。线程是在同一时间需要完成多项任务的时候实现的。
并发和并行：
- 并发当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程，它只能把CPU运行时间划分成若干个时间段,再将时间段分配给各个线程执行，在一个时间段的线程代码运行时，其它线程处于挂起状。.这种方式我们称之为并发(Concurrent)。
- **并行：**当系统有一个以上CPU时,则线程的操作有可能非并发。当一个CPU执行一个线程时，另一个CPU可以执行另一个线程，两个线程互不抢占CPU资源，可以同时进行，这种方式我们称之为并行(Parallel)。

2.线程的状态

new（新建）：线程刚刚被创建，但是并未启动，还没有调用start方法。
Runnable（可运行）：线程可以在Java虚拟机中运行的状态，可能正在运行自己的代码，也可能没有，这取决于操作系统处理器。
Blocked（锁阻塞）：当一个线程试图获取一个锁对象，而该对象被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting（无限等待）：一个线程在等待另一个线程执行动作是，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting（计时等待）：同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者收到唤醒通知。带有超时参数的常用方法有Thread.sleep、Object.wait。
THRMINATED（死亡状态）：因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ElvjEnsV-1592270544039)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200615133529687.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-za9aTWMo-1592270544042)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200612154424160.png)]

3.线程怎么创建

继承Thread类，重写run方法
实现Runnable接口，重写run方法
通过Callable和FutureTask创建线程
通过线程池创建线程
1 、2 通过重写run方法，run方式的返回值是void，所以没有办法返回结果
3 、4 有返回值，通过Callable接口，就要实现call方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中

继承Thread类，重写run方法 ，通过子类构造方法来入参无返回值

package Thread;

import java.time.LocalDateTime;

public class ThreadCreateDemo1 extends Thread{

    private String runName;
    public ThreadCreateDemo1(String runName) {
        this.runName=runName;
    }

    @Override
    public void run() {
        System.out.println(runName+" run time "+LocalDateTime.now());
    }

    public static void main(String[] args) {
        new ThreadCreateDemo1("thread1").start();
        new ThreadCreateDemo1("thread2").start();
        new ThreadCreateDemo1("thread3").start();

        /*
        main result:
            thread2 run time 2020-06-13T12:37:07.507
            thread3 run time 2020-06-13T12:37:07.507
            thread1 run time 2020-06-13T12:37:07.507
        */
    }
}

实现Runnable接口，重写run方法 实现类的实例作为Thread构造函数的入参，通过调用Thread的start()方法启动线程；
无返回值

package Thread;

import java.time.LocalDateTime;

public class ThreadCreateDemo2 implements  Runnable{
    private String runName;
    public ThreadCreateDemo2(String runName) {
        this.runName = runName;
    }

    @Override
    public void run() {
        System.out.println(runName+" run time:"+ LocalDateTime.now());
    }

    public static void main(String[] args) {
        new Thread(new ThreadCreateDemo2("threadRun1")).start();
        new Thread(new ThreadCreateDemo2("threadRun2")).start();
        new Thread(new ThreadCreateDemo2("threadRun3")).start();
        /*
            main result:
            threadRun2 run time:2020-06-13T12:37:39.650
            threadRun3 run time:2020-06-13T12:37:39.650
            threadRun1 run time:2020-06-13T12:37:39.650
         */
    }
}

通过Callable和FutureTask创建线程
1、实现Callable(V)接口，并实现Call方法；
2、创建Callable实现类的实现，使用FutureTask类包装Callable对象(该FutureTask对象封装了Callable对象的Call方法的返回值 )；
3、使用FutureTask对象作为Thread对象的构造方法入参，创建并启动线程；
4、调用FutureTask对象的get()来获取子线程执行结束的返回值；
有返回值

public class MyThreadImpl03 implements Callable<String> {

    private String title;

    public MyThreadImpl03(String title) {
        this.title = title;
    }

    @Override
    public String call() throws Exception {
        //自己的线程处理逻辑代码
        System.out.println(this.title + "运行:" + LocalDateTime.now());
        return this.title + "执行完毕!";
    }

    //测试
    public static void main(String[] args) throws Exception {
        FutureTask futureTask1 = new FutureTask(new MyThreadImpl03("线程A"));
        FutureTask futureTask2 = new FutureTask(new MyThreadImpl03("线程B"));
        FutureTask futureTask3 = new FutureTask(new MyThreadImpl03("线程C"));

    new Thread(futureTask1).start();
    new Thread(futureTask2).start();
    new Thread(futureTask3).start();

    System.out.println("线程A返回：" + futureTask1.get());
    System.out.println("线程B返回：" + futureTask2.get());
    System.out.println("线程C返回：" + futureTask3.get());
    }
}

执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的对象了。get方法是阻塞的，如果线程无返回结果，get方法会一直等待。

通过线程池创建线程（本文以Executors举例说明，在实际当中不建议使用Executors，而是直接使用ThreadPoolExecutor来创建线程池；有返回值）

public class MyThreadImpl04 implements Runnable {

    private static int POOL_NUM = 5;     //线程池数量
    private String title;

    public MyThreadImpl04(String title) {
        this.title = title;
    }

    @Override
    public void run() {
        //自己的线程处理逻辑代码
        System.out.println(this.title + "运行:" + LocalDateTime.now());
    }

    //测试
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = null;
        try {
            executorService = Executors.newFixedThreadPool(5);
            for (int i = 1; i <= POOL_NUM; i++) {
                MyThreadImpl04 thread = new MyThreadImpl04("线程" + i);
                //Thread.sleep(1000);
                executorService.execute(thread);
            }
        } catch (Exception e) {
            throw e;
        } finally {
            //关闭线程池
            if (null != executorService) {
                executorService.shutdown();
            }
        }

    }

}

ExecutoreService提供了submit()方法，传递一个Callable或Runnable，返回Future；
如果Executor后台线程池还没有完成Callable的计算，Future对象的get()方法，会阻塞直到计算完成；
Executors类：提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口

4.线程的常用方法

静态方法
- currentThread()方法 :返回代码段正在被哪个线程调用的信息。
- sleep()方法: 在指定的毫秒数内让当前“正在执行的线程”休眠（暂停执行）。
  
  sleep相当于让线程睡眠，交出CPU，让CPU去执行其他的任务。
```
sleep(``long` `millis)   ``//参数为毫秒``
sleep(``long` `millis,``int` `nanoseconds)  ``//第一参数为毫秒，第二个参数为纳秒
```
  注意：
  - 当线程睡眠时间满后，不一定会立即得到执行，因为此时可能CPU正在执行其他的任务。所以说调用sleep方法相当于让线程进入阻塞状态。
  - sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。
- yield()方法：让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。
  
  注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。
对象方法

start():用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。
run()：run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。
getId()：取得线程的唯一标识
isAlive()：判断当前线程是否处于活动状态
join()：在很多情况下，主线程创建并启动了线程，如果子线程中药进行大量耗时运算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join()方法了。方法join()的作用是等待线程对象销毁。
getName和setName：用来得到或者设置线程名称。
getPriority和setPriority：用来获取和设置线程优先级。
setDaemon和isDaemon：用来设置线程是否成为守护线程和判断线程是否是守护线程。

守护线程和用户线程的区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖。举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像垃圾收集器线程就是守护线程。
ity和setPriority**：用来获取和设置线程优先级。

setDaemon和isDaemon：用来设置线程是否成为守护线程和判断线程是否是守护线程。

守护线程和用户线程的区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖。举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像垃圾收集器线程就是守护线程。

zzcheng_gogo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线程简介及创建代码

线程1.什么是线程、多线程线程(thread)：操作系统进行运算调度的最小单位。是进程中的实际运作单位，一个进程可以有很多线程，每条线程并行执行不同的任务。多线程(multithreading):从软件或者硬件上实现多个线程并发执行的技术。同一时间执行多个线程，提升整体处理性能多线程作用：为了同步完成多项任务，不是为了提高运行效率，而是为了提高资源使用效率来提高系统的效率。线程是在同一时间需要完成多项任务的时候实现的。并发和并行：并发当有多个线程在操作时,如果系统只有一个C
复制链接

扫一扫