注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

饥民2011

一直在搬砖

 
 
 

日志

 
 
 
 

Java 里的thread (线程)简介  

2014-05-01 17:06:54|  分类: Java |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

在Java里 thread 就是线程的意思.

说到线程的概念, 自然离不开另外两个词: 程序和进程.

从最基本的程序讲起:


一. 什么是程序(Program)

所谓程序, 就是1个严格有序的指令集合. 程序规定了完成某一任务时,计算机所需要做的各种操作, 以及操作的顺序.


1.1 单道程序运行环境

所谓单道程序环境就是指, 计算机除了操作系统之外, 只允许运行1个用户程序.

以前的DOS系统就是1个典型的单道程序运行环境.


单道程序有如下特点:

1. 资源的独占性: 任何时候, 内存内只有1个用户程序, 这个程序独享系统的所有资源.

2. 执行顺序性: 内存中只执行1个程序, 各程序是按次序执行的, 即是做完1件事后, 才做另一件事.

            绝不可能执行1个程序的中途暂停, 然后去执行另1个程序.

3.结果的再现性: 只要执行环境和初始条件相同, 重复执行1个程序, 获得的结果总是一样的.


1.2 多道程序运行环境

所谓多道程序运行环境是指, 计算机除了操作系统之外, 允许同时运行多个用户程序.

当今的unix, linux都是典型的多道程序运行环境.


多道程序有如下特点:

1. 间断性: 也就是cpu会在多个程序之间切换执行, 例如cpu执行程序A一段时间后, 会切换去执行程序B一段时间.

                  由于这个时间段很短, 所以对用户造成1个程序A和程序B同时执行的假象.


2. 失去封闭性:  程序执行受外界影响, 也就是多个程序之间共享资源, 互相制约.

3. 不可再现性:  重复执行时, 可能得到不同的结果. 原因就是上面的点, 执行时可能会受到内存中其他程序的影响.

二. 什么是进程(process)

进程这个概念是基于多道程序运行环境来讲的. 

1个进程就是程序在内存中运行的1个实例


由于在多道程序运行环境中, 同1个程序可以同时产生两个实例在内存里运行.


举个简单例子:  例如你可以在操作系统打开两个gvim 文本编辑器, 同时编辑两个不同的文件.

这时执行ps -ef | grep gvim 就会见到系统中有两个名字是gvim的进程, 但是它们的进程id是不同的.


也就是将,  gvim这个程序在内存中生成两个进程同时运行.


在多道程序运行环境中.  引用进程这个概念来描叙程序在内存里事例, 用来区别于程序本身.


真正深入了解进程并不简单, 进程其实算是属于操作系统这门课的范畴. 1个进程包括程序段, 数据段, 程序控制块等,  但是作为一个普通的程序猿, 没必要理解得这么深入.


三. 什么是线程(thread).

相对地, 我认为作为1个普通的程序猿, 必须深入了解线程这个概念.


其实, 线程就是1个进程的执行路径.

一般的java程序都是从启动类的main函数入口开始执行, main函数的结束而停止.   这条执行路径就是java程序的主线程.


也就是讲:

线程是相对于进程来讲的, 1个进程至少存在1条线程.


而java允许多线程编程, 也就是1个进程除主线程外,  还允许存在1个或若干个其他线程, cpu会在这些线程当中间断切换执行, 给用户造成同时执行的假象.



四. 1个单线程java程序的简单例子.

例子如下:

  1. package Thread_kng;  
  2.   
  3. class S_thrd_1{  
  4.     public void f(){  
  5.         while (true){  
  6.             System.out.printf("Thread main is runing!\n");  
  7.         }  
  8.   
  9.         //System.out.printf("f() is done!\n");  //compilation fail  
  10.     }  
  11. }  
  12.   
  13. public class S_thread_expl{  
  14.     public static void g(){  
  15.         S_thrd_1 s = new S_thrd_1();  
  16.         s.f();    
  17.         System.out.printf("g() is done!\n");  
  18.     }  
  19. }  

上面的例子中,  g() 函数调用了f() 函数,

g()函数在最后尝试输出"g() is done!" , 但是因为f() 是一个无限循环.  所以g() 调用f()后, 根本没机会执行后面的语句!


也就是说, 虽然g() 跟 f() 是两个不同类的函数, 但是它们是在程序中的同一个线程(主线程)内执行.   

在同一个线程内, 语句总是按程序猿编写的顺序依次执行, 一条语句未执行完时, 不会跳到后面执行其他的语句.



五. 1个多线程java程序的简单例子.

例子如下:

  1. package Thread_kng;  
  2.   
  3. class M_thrd_1 extends Thread{  //extends  
  4.     public M_thrd_1(String name){  
  5.         super(name);  
  6.     }  
  7.   
  8.     public void run(){ //overwrite the method run() of superclass  
  9.         while (true){  
  10.             System.out.printf("Thread " + this.getName()+ " is runing!\n");  
  11.         }  
  12.   
  13.         //System.out.printf("f() is done!\n");  //compilation fail  
  14.     }  
  15. }  
  16.   
  17. public class M_thread_expl{  
  18.     public static void g(){  
  19.         M_thrd_1 s = new M_thrd_1("T1");  
  20.         s.start(); //start()method is extended from superclass, it will call the method run()  
  21.         M_thrd_1 s2 = new M_thrd_1("T2");  
  22.         s2.start();  
  23.         System.out.printf("g() is done!\n");  
  24.     }  


上面例子中, 类 M_thrd_1继承了线程类Thread.  并重写了run方法.

在下面的g()函数中.

实例化了两个类M_thrd_1的对象s, s1 的对象.

执行了start()方法.

start()方法继承字Thread, 它会启动1新线程, 并调用run()函数.

而g()后面本身也在不断循环输出"THread Main is running"


所以输出如下:





可以 见到, 输出结果是T1,T2 和Main 交替输出在屏幕上.


实际上, 这个程序有3个线程.

其中1个就是主线程.

主线程main通过实例化两个M_thrd_1的对象, 调用其start()函数开启了两个子线程.

其中1个子线程不断输出T1

另1个子线程不断输出T2


但是主线程并不会等待其子线程执行完成, 会继续执行下面的代码,所以不断循环输出Main!


所以这个例子实际上要3个线程在输出信息到屏幕了!


六. Java 开启一条新进程的两种方式.

java开启一条新线程, 有两种方式. 但是都要利用java的线程基类Thread.


6.1 方式1. 创建Thread的派生类

这个就类似上面的例子:

具体步骤如下:


6.1.1 线程准备: 新建1个类, 继承线程类Thread.  将业务代码写入重写后的run() 方法中.

例如上面的例子中的M_thrd_1类

  1. class M_thrd_1 extends Thread{  //extends  
  2.     public M_thrd_1(String name){  
  3.         super(name);  
  4.     }  
  5.   
  6.     public void run(){ //overwrite the method run() of superclass  
  7.         while (true){  
  8.             System.out.printf("Thread " + this.getName()+ " is runing!\n");  
  9.         }  
  10.   
  11.         //System.out.printf("f() is done!\n");  //compilation fail  
  12.     }  
  13. }  

可以见到, 我们将线程要执行的业务代码写入了run() 方法.



6.1.2 启动线程: 新建1个上述类的对象, 运行start()方法

例如

M_thrd_1 s = new M_thrd();

s. start();


其中start() 是类M_thrd_1 继承自超类Thread的.

我们看看JDK API 对start() 方法的定义:


 void  start()
          使该线程开始执行;Java 虚拟机调用该线程的 run 方法。


可以见到, 调用了start() 方法后, 会开始执行改线程, 也就是在当前线程下开启一条新线程.

而这条新线程做什么呢, 就是执行run()里面的代码.


所以我们一般只需要把也业务的代码写入run()里面就ok了. 不要重写start()方法.


注意, 如果直接执行s.run(); 则会在当前线程下执行run里面的代码, 并没有开启一条新线程. 区别很大的.



6.2 方式2. 创建1个类, 实现Runnable 接口

步骤跟上面的方式差别不大

6.2.1 线程准备: 新建1个类, 实现接口Runnable. 将业务代码写入重写后的run() 方法中.

例子:

  1. class M_thrd_2 implements Runnable{  //extends  
  2.     public int id = 0;  
  3.   
  4.     public void run(){ //overwrite the method run() of superclass  
  5.         while (true){  
  6.             System.out.printf("%s: Thread " + this.id+ " is runing!\n", Thread.currentThread().getName());  
  7.         }  
  8.   
  9.         //System.out.printf("f() is done!\n");  //compilation fail  
  10.     }  
  11. }  

上面的例子 M_thrd_2 就实现了接口Runnable

并重写了接口Runnable 的抽象方法run();


注意.  currentThread() 是类Thread的一个静态方法, 作用是获取当前语句所在的线程.


6.2.2 启动线程: 新建1个上述类的对象s, 在新建1个类Thread的对象t, 把s作为一个参数用于t的构造方法.  并执行t.start()

貌似比方式一复杂.

其实非如下:

new Thread(new M_thrd_2()).start()


例子:

  1. public class M_thread_expl2{  
  2.     public static void g(){  
  3.         M_thrd_2 s = new M_thrd_2();  
  4.         s.id = 1;  
  5.         Thread t1 = new Thread(s);  
  6.         t1.start();  
  7.   
  8.         Thread t2 = new Thread(s);  
  9.         s.id = 2;  
  10.         t2.start();  
  11.     }  
  12. }  

在g() 函数中,

首先新建1个类M_thrd_2的 对象s.

并利用s作为参数 建立了两个线程类Thread的对象t1 和 t2. 并启动这两个线程.


注:

1. 这个例子中有3个线程, 其中1个主线程(也就是g() 函数所在的线程). 开启了两个子线程, 该两个子线程都在不断循环输出信息到屏幕上.

2. Thread(object ob) 是1个属于类Thread的构造方法,  其中的对象ob 必须实现Runnable 接口.

3. 这个例子执行时 , 第一个t1首先会输出id = 1,    但是当第二个线程t2开始执行后, t1会输出id=2,  因为t1, 和t2都是利用同1个对象建立的.

    也就是说, 这个对象的变动会同时影响两个线程.


输出如下:




6.3 两种方式的区别

1.  方式1是创建继承类Thread的派生类,  方式2是创建实现Runnable接口的类.

2.  启动方式:  方式1是直接调用业务类的对象的start()方法, 方式2是利用业务类类的对象新建1个类Thread的对象, 并调用该对象的start()方法.

3.  如果要启动多个线程, 通过方式1需要新建多个不同业务类的对象, 方式2 则可以通过业务1个对象 构建多个Thread类对象, 但是业务对象的变动会同时影响对应的多个线程.



七. 关于线程的一些常用方法介绍.

7.1 run()

我们要吧线把要执行的业务代码写入这个方法. 上面提过了.  注意, 如果我们直接执行1个线程对象的run()方法可以合法的, 但是仍然是在当前线程内执行, 并没有开始一条新线程.


7.2 Start()

当1个线程or其派生类执行1个start()方法. 就开启1个新线程, 并调用该类的run()方法.

注意: 1个线程如果已经调用过一次start(), 再调用start()则或抛异常.


7.3 stop()

停止1个1个线程.


7.4 setName() 和 getName()

设置和获得对应线程的名字.


7.5 Thread.currentThread()

注意这个方法是一个static方法,  而上面的都不是静态方法.


这个方法返回当前执行语句所属的线程.


例如1个线程对象A.    它的run() 方法里调用了 Thread.currentThread().getName() 函数.

假如直接执行A.run()  则返回的是当前线程(而不是A线程) 的名字,  因为对象A并没有启动自己的线程.

假如执行难过A.start(), 那么该函数就返回A启动的线程的名字了.



八, 小结

这篇文章只是简介, 很多重要的方法例如 sleep() , wait() 等都没有介绍, 这些是线程控制的内容. 本吊打算在另一篇博文里介绍.
  评论这张
 
阅读(107)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017