进程和线程

最新推荐文章于 2025-05-05 00:58:42 发布

A__17

最新推荐文章于 2025-05-05 00:58:42 发布

阅读量910

点赞数

CC 4.0 BY-SA版权

分类专栏：操作系统

本文链接：https://blog.youkuaiyun.com/wodewutai17quiet/article/details/48896055

操作系统专栏收录该内容

5 篇文章

订阅专栏

进程和线程：

进程：是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以有多个线程。比如在Windows系统中，一个运行的xx.exe就是一个进程。
线程：是指进程中的一个执行任务，一个进程中可以运行多个线程,多个线程可共享数据

进程与线程的区别：

进程有独立的进程空间，进程中的数据存放空间（堆空间和栈空间）是独立的。
线程的堆空间是共享的，栈空间是独立的，线程消耗的资源也比进程小，相互之间可以影响的。

线程的生命周期：

新建(New)：当程序创建了一个线程后，该线程处于新建状态。
就绪(Ready)：当线程对象调用启动方法后，该线程处于就绪状态，线程计入线程队列排队，此时该状态线程并未开始执行，它仅表示可以运行了
运行(Running)：若处于就绪状态的线程获得了CPU，开始执行run()线程执行体，该线程处于执行状态
阻塞(Blocked)：线程运行过程中需要被中断
1. 注意：阻塞状态不能直接转成运行状态，阻塞状态只能重新进入就绪状态
2. 线程阻塞的原因：
  - 线程(调用sleep方法或wait方法)主动放弃占用的CPU资源。
  - 线程调用了阻塞式的IO方法，在该方法返回前，线程被阻塞。
  - 线程访问临界资源时，没有获取到相关的锁。
  - 线程被挂起。
死亡(Terminated)
1. 线程正常结束。
2. 线程抛出未捕获的Exception或Error

java中的线程：

创建线程三种方式：

继承Thread类：

           1>子类重写父类中的run方法。
           2>建立子类对象的同时线程也被创建。
           3>通过调用start方法启动线程：new MyThread().start();

           特点：不能再继承其他类了，同份资源不共享。

           注意：Thread类实现了Runnable接口

实现Runnable接口：

           1>子类覆盖接口中的run方法。
           2>通过Thread类创建线程，并将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数。
           3>Thread类对象调用start方法启动线程：
               new Thread(new Runnable(){
                   public void run() {
                       ...
                   }
               }).start();

           特点：
               1>多个线程共享一个目标资源(即run方法中的内容)，适合多线程处理同一份资源。
               2>该类还可以继承其他类，也可以实现其他接口，扩展性较好。

实现Callable接口(jdk1.5)：

           java.util.concurrent包下的Callable接口：

               public interface Callable<V> {
                   V call() throws Exception;
               }

           Callable和Runnable的区别：
               1)Callable定义的方法是call，而Runnable定义的方法是run。
               2)Callable的call方法可以有返回值，而Runnable的run方法不能有返回值。
               3)Callable的call方法可抛出异常，而Runnable的run方法不能抛出异常。

线程的状态(生命周期)：

       java.lang.Thread.State

       public enum State {
           // Thread state for a thread which has not yet started.
           NEW, // 新建状态

           /**
           * Thread state for a runnable thread.
           * A thread in the runnable state is executing in the Java virtual machine but it may
           * be waiting for other resources from the operating system such as processor.
           * java将操作系统中运行和就绪两个状态合并称为运行状态。我们也可以细分一下：
           *        就绪状态：当线程对象调用start()方法后，该线程处于就绪状态，线程计入线程队列排队，此时该线程并未开始执行，它仅表示线程已经准备就绪。
           *        运行状态：若处于就绪状态的线程获得了CPU，开始执行run()线程执行体，此时该线程处于运行状态。
           */
           RUNNABLE, // 运行状态

           /**
           * Thread state for a thread blocked waiting for a monitor lock.
           * A thread in the blocked state is waiting for a monitor lock to enter a synchronized block/method or reenter a synchronized block/method after calling {Object.wait}.
           * 线程在访问synchronized修饰的方法或方法块时，因无法获得监视器而进入阻塞状态。或者是线程进入同步方法(同步代码块)后调用了Object.wait()方法。
*/
           BLOCKED, // 阻塞状态

           /**
           * Thread state for a waiting thread.
           * A thread is in the waiting state due to calling one of the following methods:
           ***** {Object.wait} with no timeout *****
           ***** {Thread.join} with no timeout *****
           ***** {LockSupport.park}           *****
           *
           * A thread in the waiting state is waiting for another thread to perform a particular action.
           *
           * For example, a thread that has called Object.wait() on an object is waiting for another thread to call Object.notify() or Object.notifyAll() on that object.
           * A thread that has called Thread.join() is waiting for a specified thread to terminate.
           *
           * 注意：线程因无法获取到java.util.concurrent.locks.lock锁，进入等待状态，而不是进入阻塞状态！因为lock是使用LockSupport的park()方法来实现线程的阻塞。
           */
           WAITING, // 等待状态

           /**
           * Thread state for a waiting thread with a specified waiting time.
           * A thread is in the timed waiting state due to calling one of the following methods with a specified positive waiting time:
           * {Thread.sleep}
           * {Object.wait} with timeout
           * {Thread.join} with timeout
           * {LockSupport.parkNanos}
           * {LockSupport.parkUntil}
           */
           TIMED_WAITING, // 超时等待状态

           /**
           * Thread state for a terminated thread.
           *    进入死亡状态的场景：
           *        1)run()执行完成，线程正常结束
           *        2)线程抛出未捕获的Exception或Error
           *        3)调用线程的stop() (易导致死锁，不推荐)
           *   注意：
           *       1)主线程结束后，其他线程不受其影响，不会随之结束;一旦子线程启动起来后，就拥有和主线程相等地位，不受主线程影响。
           *       2)测试线程是否活着，可用线程对象的isAlive()方法。
           *        3)已死亡的线程是不可能通过start()方法唤醒线程的(线程死不能复生)，否则引发IllegalThreadStateException异常
           */
           TERMINATED; // 死亡状态(或结束状态)
       }