线程基础:有关线程的概念与实现方法

目录

一、线程的概念

1、进程

2、线程

3、进程与线程的区别

二、线程的实现

1、继承Thread类

2、实现Runnable接口

3、实现Callable接口

4、三种实现方法的区别

三、线程的生命周期

四、线程的常用方法

总结



一、线程的概念

1、进程

进程是运行中的程序,是执行相关程序(CPU、内存、磁盘等)的基本单位,进程与进程之间是相互独立的,有着属于自己的内存空间。

2、线程

线程是执行CPU资源的基本单位,属于一种特别的进程,因此执行一个线程所需要的资源更少,作为一种轻量级的进程。

3、进程与线程的区别

  1. 进程包含n个线程
  2. 线程作为一种轻量级的进程,因此他们之间的通信更为方便
  3. 进程有着自己的内存空间,线程也有自己的内存空间

二、线程的实现

1、继承Thread类

  1. 继承Thread类

  2. 重写run方法

  3. 调用start启动线程

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0;i < 2000;i++){
            //执行2000次线程
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

public class ThreadDemo {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
//        myThread.start();
        for (int i = 0;i < 2000;i++){
            System.out.println(Thread.currentThread().getName()+i);
        }
    }

}

这里我尝试了调用两次start方法,发现它会报错。探究了一下原因之后发现是与线程的生命周期有关。

当一条线程执行完它所有的代码之后会进入到死亡状态,这是无法逆转的,因此再次执行start方法是不行的

2、实现Runnable接口

  1. 实现Runnable接口

  2. 实现run方法

  3. 创建实现Runnable接口的对象,传入Thread对象中

  4. 启动线程

public class RunnableDemo {

    public static void main(String[] args) {


        new Thread(() ->{
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+i);
            }
        }).start();

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int j = 0; j < 5; j++) {
                    System.out.println(Thread.currentThread().getName()+j);
                }
            }
        });
        thread.start();
    }
}

3、实现Callable接口

  1. 实现Callable接口,实现call方法

  2. 创建Callable对象,传入FutureTask对象

  3. 创建FutureTask对象,传入Thread对象

  4. 启动线程

  5. 调用get方法得到返回结果

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

public class CallableDemo {
    public static void main(String[] args) {
        FutureTask<Long> task = new FutureTask<>(() -> {
            long sum = 0;
            for (long i = 0; i < 100000000000L; i++) {
                sum += i;
            }
            return sum;
        });
        Thread thread = new Thread(task);
        thread.start();
        System.out.println("-------");

        try {
            System.out.println(task.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4、三种实现方法的区别

首先是继承Thread和实现Runnable的区别

  1. 继承Thread类,不能继承其它的类,语法有限制

  2. 实现Runnable接口,可以继承其它类,语法没有限制

  3. Runnalbe接口强制要求实现run方法,不容易出现错误

实现Callable接口可以返回值,继承Thread类和Runnable不行

三、线程的生命周期

  • 新建

当开始new线程对象时,线程就处于一个新建状态

  • 准备

使用对象的start方法,线程就处于一个准备状态

  • 运行

当这个对象得到了CPU的资源只有,就处于一种运行状态,失去CPU资源后就会回到准备状态

  • 死亡

当线程将代码执行完毕之后,就会进入死亡状态

  • 阻塞

阻塞是线程在运行中遇到的一些特殊情况。比如说sleep方法,可以将线程进行休眠,这样线程就会处于一种阻塞状态,当结束睡眠就会回到准备状态,等待CPU资源的利用

四、线程的常用方法

方法介绍
start()启动
stop()停止(禁用,可能导致线程死锁等问题),停止线程可以让run执行结束
String getName()获得线程的名字
setName(String)设置线程名字
sleep(long)进入睡眠,毫秒
setPriority(int)设置线程的优先级(1~10从低到高)越高抢CPU几率更高
setDaemon(boolean)设置为后台线程 true ,后台线程是为其它线程服务的,如果没有其它线程存在,就自动死亡;使用案例:GC就是一种后台线程
join()线程的加入(合并)让其它线程先执行完,再执行自己的指令


总结

线程是一种轻量级的进程,有着自己的内存空间,一个进程可以包含n个线程

实现线程的方法有3种:继承Thread类、实现Runnable接口、实现Callable接口。它们之间的区别在于,当要得到返回值时,实现Callable接口。实现Runnable接口,可以继承其它类,语法没有限制,并且强制要求实现run方法,不容易出现错误

  • 3
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值