Java并发编程1:进程与线程概述

进程和线程

在学习Java并发编程的过程中,往往涉及多线程的问题。说到多线程,就要先明确进程和线程的概念。

进程

在操作系统中,进程被定义为程序在一个数据集合上运行的过程,是系统进行资源分配和调度的一个独立单位

说白了就是受操作系统管理的基本运行单元。打开我们的任务管理器,现在正在运行的chrome、金山PDF等都可以理解为一个进程。


进程与程序的区别

①进程是主动的(active)动态的,强调执行过程,它动态地创建,并被调度执行后消亡;程序是被动的(passive)静态的,是指令的有序集合,没有任何执行的含义。

②进程是暂时的,是一个状态变化的过程;程序是永久的,可长久保存。

③进程与程序的组成不同:进程的组成包括程序。

④进程与程序的对应关系:通过多次执行,一个程序可对应多个进程;通过调用关系,一个进程可包括多个程序。

进程的基本特征

动态性:进程是程序的一次执行过程,是动态的,即有生命周期。因创建而产生,因调度而执行,因得不到资源而暂停执行,最后由撤销而消亡。

并发行:引入进程的目的,是为了多个进程可同时存在于系统中并可以并发执行,以提高资源利用率。

独立性:进程是系统中独立运行的基本单位,也是系统中可独立获得资源和独立调度的基本单位。

异步性:系统中各个进程按各自独立、不可预知的速度向前推进,这将导致程序的不可再现性(结果不确定)。

结构特征:为了方便系统对进程进行管理和控制,采用PCB(进程控制块)对进程进行描述。从结构上看,进程由程序段、数据段、程序控制块(PCB)三部分构成。

进程的状态转换

在操作系统中,进程的基本状态转换如下图所示:


·引起进程状态转换的原因

①处理机调度

②进程在运行过程中需要等待某一事件

③进程所等待的事件发生

·挂起状态的引入

进程由内存调到外存进入挂起状态。主要有以下几个原因:

①终端用户的请求

②父进程请求

③负荷调节的需要

④操作系统的需要

线程

操作系统中,进程是一个资源拥有者,在创建、撤销、切换、调度时系统开销较大,使系统中进程数有限,这将影响进程并发度。引入线程,是为了减少程序并发执行时所付出的时空开销,使操作系统具有更好的并发性,以改善资源利用率及提高系统吞吐量。

线程是进程内一个相对独立的可调度的执行单元,就相当于进程中的一个子任务。比如当使用微信时,就有很多子任务在运行,聊天、视频、文件上传下载等。

线程的状态和控制

①线程创建

进程创建时也创建了该进程内的线程。随后进程内的线程又可创建另外的线程,为新线程设定指令指针和参数,提供寄存器上下文和栈空间,并将其放入就绪队列。

②线程阻塞

当一个线程需要等待一个事件,将被阻塞。在保护相关现场后,处理机可以去执行其他的就绪线程。

③线程解除阻塞

当线程等待的事件发生后,可解除原来的阻塞状态,将其移至就绪队列中

④线程终止

当线程完成后,释放它占用的寄存器上下文和栈空间

线程与进程的关系

进程是系统中资源分配的基本单位。一个进程由多个线程构成,这些线程共享该进程的系统资源。

两者比较:

①调度

同一进程的多线程间调度时,不引起进程的切换;

不同进程的线程间调度,需要进程切换

②并发行

一个进程的多个线程之间可并发执行

③资源的拥有

线程不拥有系统资源、代码段、数据段等

④系统开销

线程:系统仅为其保存少量寄存器内容

进程:整个当前CPU环境

⑤安全性

同一进程的多线程共享所有资源。一个错误的线程可以改变另一个线程使用的数据而导致错误发生。采用多进程的系统中,系统不允许一个进程有意或无意地破坏另一个进程。从安全性角度,使用多进程比多线程可能更安全。

Java创建线程的方式

Java创建线程的方式有两种:1.继承Thread,重写父类的run()方法 2.实现Runnable接口。

①继承Thread,重写run()方法

/**
 * 创建一个子线程,完成1-100之间自然数的输出。同样地,主线程执行同样的操作。
 * 创建多线程的第一种方式:继承java.lang.Thread类
 * Created by Wavy on 2018/4/17.
 */
//1.创建一个继承于Thread的子类
class SubThread extends Thread{
    //2.重写Thread类的run()方法
    public void run(){
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestThread {
    public static void main(String[] args) {
        //3.创建一个子类的对象
        SubThread st = new SubThread();
        //4.调用线程的start(),启动此线程;调用相应的run()方法
        //5.一个线程只能执行一次start()
        //6.不能通过Thread实现类对象的run()去启动一个线程
        //st.run();
        st.start();

        //主线程执行的内容
        for (int i = 1; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

②实现Runnable接口

/**
 * 创建多线程的方式二:通过实现的方式
 *
 * Created by Wavy on 2018/4/17.
 */
//1.创建一个实现Runnable接口的类
class PrintNum1 implements Runnable{
    //2.实现接口的抽象方法
   public void run(){
       for(int i=1;i<=100;i++){
           if(i%2==0)
               System.out.println(Thread.currentThread().getName()+":"+i);
       }
   }
}
public class TestThread2 {
    public static void main(String[] args){
        //3.创建一个Runnable接口实现类的对象
        PrintNum1 p = new PrintNum1();
        //4.将此对象作为形参传递给Thread类的构造器中,创建Thread类的对象,此对象即为一个线程
        Thread t = new Thread(p);
        //5.调用start()方法,启动线程并执行run()方法
        t.start();

        //再创建一个线程
        Thread t2 = new Thread(p);
        t2.start();
    }
}

比较继承方式和实现方式:

①联系:Thread类也实现了Runnable接口。


②实现的方式优于继承的方式:

1.实现方式避免了java单继承的局限性。

2.实现的方式比继承的方式更有利于减少程序之间的耦合。

3.如果多个线程要操作共享数据,使用实现的方式更合适。因为当使用继承方式时,需要将共享数据设置为static,只有当其所属的类作用结束时,才会从内存中清除掉。以窗口售票为例,举例如下:

>继承的方式

/**
 * 模拟火车站售票窗口,开启三个窗口售票,总票数为100张
 * Created by Wavy on 2018/4/17.
 */
class Window1 extends Thread{
    //需要将ticket设置成静态的
    static int ticket = 100;
    public void run(){
        while(true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()
                        +"售票,票号为:"+ticket--);
            }else{
                break;
            }
        }
    }
}
public class TestWindow1 {
    public static void main(String[] args){
        Window1 w1 = new Window1();
        Window1 w2 = new Window1();
        Window1 w3 = new Window1();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

>实现的方式

/**
 * 模拟火车站售票窗口,开启三个窗口售票,总票数为100张
 * Created by Wavy on 2018/4/17.
 */
class Window implements Runnable{
    int ticket = 100;
    public void run(){
        while(true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()
                +"售票,票号为:"+ticket--);
            }else {
                break;
            }
        }
    }
}
public class TestWindow {
    public static void main(String[] args){
        Window w = new Window();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/u013216537/article/details/79968753
文章标签: Java
个人分类: Java并发编程
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭