进程和线程

最新推荐文章于 2025-05-09 18:42:17 发布

To be happy oh

最新推荐文章于 2025-05-09 18:42:17 发布

阅读量115

点赞数 1

分类专栏：基础文章标签：操作系统 java

原文链接：https://blog.youkuaiyun.com/vbirdbest/article/details/81282163

版权

基础专栏收录该内容

10 篇文章

订阅专栏

有了一些小成绩就不求上进，这完全不符合我的性格。攀登上一个阶梯，这固然很好，只要还有力气，那就意味着必须再继续前进一步。

每天进步一点，加油 ! 😄

进程

进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配 CPU 时间，程序开始真正运行。

线程

线程是一条执行路径，是程序执行时的最小单位，它是进程的一个执行流，是 CPU 调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由 CPU 独立调度执行，在多 CPU 环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。

一个正在运行的软件(如迅雷)就是一个进程，一个进程可以同时运行多个任务( 迅雷软件可以同时下载多个文件，每个下载任务就是一个线程), 可以简单的认为进程是线程的集合。

线程是一条可以执行的路径。多线程就是同时有多条执行路径在同时(并行)执行。

进程与线程的关系

一个程序就是一个进程，一个程序中的多个任务或者事务就是一个线程

线程的状态

1、创建（new）状态: 准备好了一个多线程的对象，即执行了 new Thread(); 创建完成后就需要为线程分配内存
2、就绪（runnable）状态: 调用了 start() 方法, 等待 CPU 进行调度
3、运行（running）状态: 执行 run() 方法
4、阻塞（blocked）状态: 暂时停止执行线程，将线程挂起( sleep()、wait()、join()、没有获取到锁都会使线程阻塞), 可能将资源交给其它线程使用
5、死亡（terminated）状态: 线程销毁(正常执行完毕、发生异常或者被打断 interrupt() 都会导致线程终止)

多线程的三种方式：

继承 Thread
实现 Runable
实现 Callable

方式一：

/**
 * 实现 Thread 接口，使用 run 方法调用
 */
public class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + LHan.GetInstance());
        }
    }
}

方式二：

/**
 * 实现 Runnable 接口，使用 run 方法调用
 */
public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + LHan.GetInstance());
        }
    }
}

方式三：

import java.util.concurrent.Callable;

/**
 * 实现 Callable 接口，使用 call 方法调用
 */
public class MyCallable implements Callable {

    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + LHan.GetInstance());
        }
        return "MyCallable";
    }
}

Main 方法

import java.util.concurrent.FutureTask;

public class Demo {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + " :" + LHan.GetInstance());
        System.out.println(Thread.currentThread().getName() + " :" + LHan.GetInstance());

        //实现 Runnable 接口，以重写 run 方法
        MyRunnable myRunnable = new MyRunnable();
        new Thread(myRunnable).start();

        //实现 Thread 接口，以重写 run 方法
        MyThread myThread = new MyThread();
        new Thread(myThread).start();


        //实现 Callable 接口，使用 call 方法调用
        MyCallable myCallable = new MyCallable();
        try {
            FutureTask<Object> futureTask = new FutureTask<Object>(myCallable);
            new Thread(futureTask).start();

            Object lHan = futureTask.get();

            System.out.println(lHan);
        } catch (Exception e) {
            e.printStackTrace();
        }


    }
}