黑马程序员技术交流社区

标题: 关于进程和线程 [打印本页]

作者: 乔九 时间: 2012-9-5 22:42
标题: 关于进程和线程
进程和线程包含关系详解

作者: 杨习平 时间: 2012-9-5 22:50
本帖最后由杨习平于 2012-9-5 22:51 编辑

1:多线程
         (1)多线程
            A:进程：正在运行的程序，代表的是应用程序在内存中的执行区域。
            B:线程：线程是进行的执行单元，执行路径。
            C:任何一个应用程序，都至少有一条执行路径。
            D:单线程程序：应用程序只有一条执行路径。
            E:多线程程序：应用程序有多条执行路径。

            举例:360图形用户管理界面，迅雷下载，请人吃饭...
      (2)jvm启动的时候，是单线程的还是多线程的？
            是多线程的。
            假如jvm的启动时单线程的，那么，在程序的运行过程中，就可能存在着
            内存溢出的隐患。不可能等到内存溢出了，在去进行垃圾回收。所以，jvm
            启动是多线程的。至少有两个，主线程和垃圾回收线程。
      (3)java中实现多线程的方式
            A:继承Thread类
                     步骤：
                     **自定义类继承Thread类
                     **重写run方法
                     **创建自定义类的对象
                     **调用start方法

                     代码体现：

                     public class ThreadDemo extends Thread
                     {
                              public void run()
                              {
                                    //code
                              }
                     }

                     public class ThreadDemoTest
                     {
                              public static void main(String[] args)
                              {
                                    ThreadDemo td1 = new ThreadDemo();
                                    ThreadDemo td2 = new ThreadDemo();

                                    td1.start();
                                    td2.start();
                              }
                     }

            B:实现Runnable接口
                     步骤：
                     **创建自定义类实现Runnable接口
                     **在自定义类中实现Runnable接口中的run方法
                     **创建自定义类对象，并把该对象作为参数传递给
                        Thread类的构造方法来创建Thread的对象
                     **调用start方法

                     代码体现：

                     public class RunnableDemo implements Runnable
                     {
                              public void run()
                              {
                                    //code
                              }
                     }

                     public class RunnableDemoTest
                     {
                              public static void main(String[] args)
                              {
                                    RunnableDemo rd = new RunnableDemo();

                                    Thread t1 = new Thread(rd);
                                    Thread t2 = new Thread(rd);

                                    t1.start();
                                    t2.start();
                              }
                     }
      (4)Thread类中的常用的几个小方法
            A:String getName():获取线程的名称
            B:static Thread currentThread():获取当前线程的对象的引用
                     用于不是Thread类的子类获取线程对象的名称。
                     格式：Thread.currentThread().getName();
            C:void setName(String name):通过set方法设置线程对象的名称。
            D:Thread(String name):通过构造方法设置线程对象的名称。
      (5)线程的随机性原理
            CPU的特点：在同一时刻，只能有一个线程执行。
            所以，多个线程其实是在抢占CPU的资源。而CPU呢，却是在这些线程中做着高速的切换。
      (6)线程的生命周期和在生命周期中各个状态的特点
            新建：当一个线程对象被创建，但是没有开启，这个时候，只是对象线程对象开辟了
                  内存空间和初始化数据。
            就绪：新建的对象调用start方法，就到了就绪状态。
                  在这个状态的线程对象，具有执行资格，没有执行权。
            运行：当线程对象获取到了CPU的资源。
                  在这个状态的线程对象，具有执行资格，也具有执行权。

                  阻塞：运行过程中的线程由于某些原因(比如wait,sleep)，释放了执行权和执行资格。
                        当然，他们可以回到运行状态。只不过，不是直接回到。
                        而是先回到就绪状态。
            死亡：当线程对象调用的run方法结束，或者直接调用stop方法，就让线程对象死亡，
                  在内存中变成了垃圾。

2:线程同步
      (1)产生线程安全的原因
            A:多个线程访问出现延迟。
            B:线程访问的随机性

            注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。
      (2)如果判断一个线程程序有没有安全问题呢？
            A:多个线程操作共享数据
            B:这个操作是分多条语句执行的。
      (3)解决线程安全问题的方式
            A:同步代码块
            B:格式:
                     synchronized(对象)
                     {
                              //需要被同步的代码
                     }
      (4)同步代码块问题：
            A:同步代码块的锁是任意同一对象。
            B:当你发现你把某个程序加了同步后，还没有解决线程安全问题。
               这个时候，你需要考虑你使用的是否是同一把锁(对象);

作者: 杨卫腾 时间: 2012-9-5 23:29
这两者的区别：
   一个进程中存在1个或多个的线程，线程包含于进程里边
   你启动的Java程序是一个进程(JVM)
         在这个JVM里面运行着包含你创建的一些线程
举个例子：
进程是像是光缆　线程是光缆里面的光纤

作者: 杨千里 时间: 2012-9-5 23:52
本帖最后由杨千里于 2012-9-5 23:56 编辑

概念该说的上面都说完了，给你举个例，
打开你的计算机任务管理器，那里面有好多进程，那是CPU分配的，

例如迅雷下载，双击启动thunder.exe迅雷程序，cpu会给它分配一个资源，即进程，这个进程里面可以包含多个线程，
你可以下载多个电影等，，，

进程.jpg (68.86 KB, 下载次数: 32)

计算机进程

迅雷线程.jpg (29.46 KB, 下载次数: 29)

迅雷下载多线程

作者: 武庆东 时间: 2012-9-6 00:09
进程有独立的地址空间，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，所以多进程的程序要比多线程的程序健壮，一个进程开始时至少会有一个主线程。

作者: 孙鑫 时间: 2012-9-6 17:39
进程和线程的关系：
（1）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
（2）资源分配给进程，同一进程的所有线程共享该进程的所有资源。
（3）线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
（4）处理机分给线程，即真正在处理机上运行的是线程。
（5）线程是指进程内的一个执行单元，也是进程内的可调度实体。
线程与进程的区别：
（1）调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位。
（2）并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行。
（3）拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。
（4）系统开销：在创建或撤销进程的时候，由于系统都要为之分配和回收资源，导致系统的明显大于创建或撤销线程时的开销。但进程有独立的地址空间，进程崩溃后，在保护模式下不会对其他的进程产生影响，而线程只是一个进程中的不同的执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但是在进程切换时，耗费的资源较大，效率要差些。

作者: 孙岳 时间: 2012-9-6 17:44
说的简单点，操作系统是一个城市，进程是一个公司，线程是公司里的人。
一个城市可以有N个公司，一个公司可以有N个人。
但公司是不能做事情的，事情要由人来做。
所以，进程只是一个概念，一个范围，用来标记和归类的，线程才是真正办事的。
这样是不是好理解点？

作者: 乔九 时间: 2012-9-7 08:36
恩。。。谢谢，清晰多了

作者: 任艳旭 时间: 2012-9-7 11:19
进程就是一个运行中的程序。
一个进程中可以有多个线程，线程是CPU调度和分派的基本单位。我们可以理解为线程就是程序运行中的一条路径。
允许多个线程并发执行，提高程序运行效率。
例如：迅雷多线程下载，QQ多个人同时聊天。

作者: AngieFans85 时间: 2012-9-7 11:36

吕书凯发表于 2012-9-5 22:49
进程和线程的主要差别在于它们是不同的操作系统资源管理方式。

进程有独立的地址空间，一个进程崩溃后，在 ...

"但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉"

线程在一个进程里是有属于自己的地址空间的,一个线程死掉,该线程所在的进程并不会死掉,只有这个进程中的所有线程都死掉(或都说都执行结束),那么这个进程才会跟着结束.

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2