线程的基本概念
2012-09-03 17:04
309 查看
线程的概念:线程就是应用程序中的一个可执行线索,多线程就是同一个应用程序中有多个可执行线索,它们可以并发执行。
线程开始执行时,它在public void run()方法中执行。
该方法是定义的线程执行起点,像应用程序从main()开始
一样。
首先main()方法构造SimpleRunnable类的实例。实例
有自己的一个String数据,初始化为"Hello"。由实例传入
Thread类构造器,这是线程运行时处理的数据。
执行的代码是实例方法run()。
一个建立线程的例子
public class SimpleRunnable implements Runable{
private String message;
public static void main(String args[]){
SimpleRunnable r1=new SimpleRunnable("Hello");
Thread t1=new Thread(r1);
t1.start();
}
public SimpleRunnable(String message){
this.message = message;
}
public void run(){
for(;;){
System.out.println(message);
}
}
创建Thread类的子类
用这种方法生成新线程,可以按以下步骤进行:
生成Thread类的子类。
class MyThread extends Thread
1.在子类中重写run()方法。
public void run()
2.生成子类的对象,并且调用start()方法启动新线程。
MyThread thread = new MyThread();
thread.start();
3. start()方法将调用run()方法执行线程。
实现Thread子类方法的多线程示例
class FirstThread extends Thread {
public void run() {
try{
System.out.println("First thread starts running.");
for(int i=0; i<6; i++) {
System.out.println("First " + i);
sleep(1000);
}
System.out.println("First thread finishes running.");
} catch (InterruptedException e) {}
}
}
实现Thread子类方法的多线程示例
class SecondThread extends Thread {
public void run() {
try{
System.out.println("\tSecond thread starts running.");
for(int i=0; i<6; i++) {
System.out.println("\tSecond " + i);
sleep(1000);
}
System.out.println("\tSecond thread finishes running");
}catch (InterruptedException e) {}
}
}
实现Thread子类方法的多线程示例
public class ThreadTest1 {
public ThreadTest1() {
FirstThread first = new FirstThread();
SecondThread second = new SecondThread();
first.start();
second.start();
}
public static void main(String[] args) {
new ThreadTest1();
}
}
结果为:
First thread starts running.
First 0
Second thread starts running.
Second 0
First 1
Second 1
First 2
Second 2
First 3
Second 3
First 4
Second 4
First 5
Second 5
First thread finishes running.
Second thread finished.
run方法是运行线程的主体,启动线程时,由java直接调用 public void run()
停止线程,由小应用程序的stop调用线程的stop thread.stop()
sleep方法的作用,暂停线程的执行,让其它线程得到机会,sleep要丢出异常,必须捕获。
Try{sleep(100)}catch(InterruptedException e){}
实现Runnable接口
Runnable是java.lang包中的一个接口。
定义了创建和执行线程的功能。
定义了run()方法,完成具体任务的地方。
实现Runnable接口的主要步骤:
1.定义一个类实现Runnable接口,
class FirstThread implements Runnable
并且在该类中实现run()方法。
public void run()
生成这个类的对象。
FirstThread first = new FirstThread();
2.用Thread(Runnable target)构造函数生成Thread对象,然后调用start()方法启动线程。
Thread thread1 = new Thread(first);
thread1.start();
实现Runnable接口多线程示例
class FirstThread implements Runnable {
public void run() {
try {
System.out.println("First thread starts running.");
for(int i=0; i<6; i++) {
System.out.println("First " + i);
Thread.sleep(1000);
}
System.out.println("First thread finishes running.");
} catch (InterruptedException e) {}
}
}
class SecondThread implements Runnable {
public void run() {
try {
System.out.println("\tSecond thread starts running.");
for(int i=0; i<6; i++) {
System.out.println("\tSecond " + i);
Thread.sleep(1000);
}
System.out.println("\tSecond thread finished.");
}catch(InterruptedException e) {}
}
}
public class RunTest {
public RunTest() {
FirstThread first = new FirstThread();
SecondThread second = new SecondThread();
Thread thread1 = new Thread(first);
Thread thread2 = new Thread(second);
thread1.start();
thread2.start();
}
public static void main(String[] args) {
new RunTest();
}
}
结果为:
First thread starts running.
First 0
Second thread starts running.
Second 0
First 1
Second 1
First 2
Second 2
First 3
Second 3
First 4
Second 4
First 5
Second 5
First thread finishes running.
Second thread finished.
1.线程的状态
具有四种状态:
新生态:已分配内在,未高度
可执行态:start( )
阻塞态
停止态:stop( )
1,新建:
当一个Thread类或其子类的对象被创建后,进入这个状态。
这时,线程对象已被分配内存空间,其私有数据已被初始化,但该线程还未被调度,可用start()方法调度,或用stop()方法中止。
新生线程一旦被调度,就将切换到可执行状态。
2.可运行:
处于可执行环境中,随时可以被调度而执行。它可细分为两个子状态:
运行状态,已获得CPU,正在执行;
就绪状态,只等待处理器资源。
这两个子状态的过渡由执行调度器来控制。
3.阻塞:
由某种原因引起线程暂停执行的状态。
4.死亡:
线程执行完毕或另一线程调用stop()方法使其停止时,进入这种停止状态。
它表示线程已退出可运行状态,并且不再进入可运行状态。
线程优先级
Java把优先级划分为10级,用1至10的整数表示,数值越大,优先级越高。
在Thread类中定义了三个优先级常量:MIN_PRIORITY, MAX_PRIORITY和NORM_PRIORITY,其值分别为1, 10, 5。
在为线程分配优先级时,其值应该在1至10之间,否则将出错。
如果应用程序没有为线程分配优先级,则Java系统为其赋值为NORM_PRIORITY。
线程调度原则
调度就是分配CPU资源,确定线程的执行顺序。
Java采用抢占式调度方式,即高优先级线程具有剥夺低优先级线程执行的权力。
如果一个低优先线程正在执行,这时出现一个高优先级线程,那么低优先级线程就只能停止执行,放弃CPU,推回到等待队列中,等待下一轮执行,而让高优先级线程立即执行。
如果线程具有相同的优先级,则按"先来先服务"的原则调度。
Thread类定义了许多控制线程执行的方法。▼
程序中经常使用下面的方法,对线程进行控制:
start():用于调用run()方法使线程开始执行。
stop(): 立即停止线程执行,其内部状态清零,放弃占用资源。
suspend():暂停线程执行。线程的所有状态和资源保持不变,以后可以通过另一线程调用resume()方法来重新启动这个线程。
resume():恢复暂停的线程,安排暂停线程执行。
sleep(): 调整Java执行时间,所需参数是指定线程的睡眠时间,以毫秒为单位。
join():调用线程等待本线程执行结束。
yield():暂停调度线程并将其放在等待队列末尾,等待下一轮执行,使同优先级的 其它线程有机会执行 。
isAlive():判断线程目前是否正在执行状态中
线程处于“新建”状态时,线程调用方法返回false。
当一个线程调用start()方法,并占有CUP资源后,该线程的run方法就开始运行,在线程的run方法结束之前,即没有进入死亡状态之前,线程调用isAlive()方法返回true。
当线程进入“死亡”状态后(实体内存被释放),线程仍可以调用方法isAlive(),这时返回的值是false。
线程开始执行时,它在public void run()方法中执行。
该方法是定义的线程执行起点,像应用程序从main()开始
一样。
首先main()方法构造SimpleRunnable类的实例。实例
有自己的一个String数据,初始化为"Hello"。由实例传入
Thread类构造器,这是线程运行时处理的数据。
执行的代码是实例方法run()。
一个建立线程的例子
public class SimpleRunnable implements Runable{
private String message;
public static void main(String args[]){
SimpleRunnable r1=new SimpleRunnable("Hello");
Thread t1=new Thread(r1);
t1.start();
}
public SimpleRunnable(String message){
this.message = message;
}
public void run(){
for(;;){
System.out.println(message);
}
}
创建Thread类的子类
用这种方法生成新线程,可以按以下步骤进行:
生成Thread类的子类。
class MyThread extends Thread
1.在子类中重写run()方法。
public void run()
2.生成子类的对象,并且调用start()方法启动新线程。
MyThread thread = new MyThread();
thread.start();
3. start()方法将调用run()方法执行线程。
实现Thread子类方法的多线程示例
class FirstThread extends Thread {
public void run() {
try{
System.out.println("First thread starts running.");
for(int i=0; i<6; i++) {
System.out.println("First " + i);
sleep(1000);
}
System.out.println("First thread finishes running.");
} catch (InterruptedException e) {}
}
}
实现Thread子类方法的多线程示例
class SecondThread extends Thread {
public void run() {
try{
System.out.println("\tSecond thread starts running.");
for(int i=0; i<6; i++) {
System.out.println("\tSecond " + i);
sleep(1000);
}
System.out.println("\tSecond thread finishes running");
}catch (InterruptedException e) {}
}
}
实现Thread子类方法的多线程示例
public class ThreadTest1 {
public ThreadTest1() {
FirstThread first = new FirstThread();
SecondThread second = new SecondThread();
first.start();
second.start();
}
public static void main(String[] args) {
new ThreadTest1();
}
}
结果为:
First thread starts running.
First 0
Second thread starts running.
Second 0
First 1
Second 1
First 2
Second 2
First 3
Second 3
First 4
Second 4
First 5
Second 5
First thread finishes running.
Second thread finished.
run方法是运行线程的主体,启动线程时,由java直接调用 public void run()
停止线程,由小应用程序的stop调用线程的stop thread.stop()
sleep方法的作用,暂停线程的执行,让其它线程得到机会,sleep要丢出异常,必须捕获。
Try{sleep(100)}catch(InterruptedException e){}
实现Runnable接口
Runnable是java.lang包中的一个接口。
定义了创建和执行线程的功能。
定义了run()方法,完成具体任务的地方。
实现Runnable接口的主要步骤:
1.定义一个类实现Runnable接口,
class FirstThread implements Runnable
并且在该类中实现run()方法。
public void run()
生成这个类的对象。
FirstThread first = new FirstThread();
2.用Thread(Runnable target)构造函数生成Thread对象,然后调用start()方法启动线程。
Thread thread1 = new Thread(first);
thread1.start();
实现Runnable接口多线程示例
class FirstThread implements Runnable {
public void run() {
try {
System.out.println("First thread starts running.");
for(int i=0; i<6; i++) {
System.out.println("First " + i);
Thread.sleep(1000);
}
System.out.println("First thread finishes running.");
} catch (InterruptedException e) {}
}
}
class SecondThread implements Runnable {
public void run() {
try {
System.out.println("\tSecond thread starts running.");
for(int i=0; i<6; i++) {
System.out.println("\tSecond " + i);
Thread.sleep(1000);
}
System.out.println("\tSecond thread finished.");
}catch(InterruptedException e) {}
}
}
public class RunTest {
public RunTest() {
FirstThread first = new FirstThread();
SecondThread second = new SecondThread();
Thread thread1 = new Thread(first);
Thread thread2 = new Thread(second);
thread1.start();
thread2.start();
}
public static void main(String[] args) {
new RunTest();
}
}
结果为:
First thread starts running.
First 0
Second thread starts running.
Second 0
First 1
Second 1
First 2
Second 2
First 3
Second 3
First 4
Second 4
First 5
Second 5
First thread finishes running.
Second thread finished.
1.线程的状态
具有四种状态:
新生态:已分配内在,未高度
可执行态:start( )
阻塞态
停止态:stop( )
1,新建:
当一个Thread类或其子类的对象被创建后,进入这个状态。
这时,线程对象已被分配内存空间,其私有数据已被初始化,但该线程还未被调度,可用start()方法调度,或用stop()方法中止。
新生线程一旦被调度,就将切换到可执行状态。
2.可运行:
处于可执行环境中,随时可以被调度而执行。它可细分为两个子状态:
运行状态,已获得CPU,正在执行;
就绪状态,只等待处理器资源。
这两个子状态的过渡由执行调度器来控制。
3.阻塞:
由某种原因引起线程暂停执行的状态。
4.死亡:
线程执行完毕或另一线程调用stop()方法使其停止时,进入这种停止状态。
它表示线程已退出可运行状态,并且不再进入可运行状态。
线程优先级
Java把优先级划分为10级,用1至10的整数表示,数值越大,优先级越高。
在Thread类中定义了三个优先级常量:MIN_PRIORITY, MAX_PRIORITY和NORM_PRIORITY,其值分别为1, 10, 5。
在为线程分配优先级时,其值应该在1至10之间,否则将出错。
如果应用程序没有为线程分配优先级,则Java系统为其赋值为NORM_PRIORITY。
线程调度原则
调度就是分配CPU资源,确定线程的执行顺序。
Java采用抢占式调度方式,即高优先级线程具有剥夺低优先级线程执行的权力。
如果一个低优先线程正在执行,这时出现一个高优先级线程,那么低优先级线程就只能停止执行,放弃CPU,推回到等待队列中,等待下一轮执行,而让高优先级线程立即执行。
如果线程具有相同的优先级,则按"先来先服务"的原则调度。
Thread类定义了许多控制线程执行的方法。▼
程序中经常使用下面的方法,对线程进行控制:
start():用于调用run()方法使线程开始执行。
stop(): 立即停止线程执行,其内部状态清零,放弃占用资源。
suspend():暂停线程执行。线程的所有状态和资源保持不变,以后可以通过另一线程调用resume()方法来重新启动这个线程。
resume():恢复暂停的线程,安排暂停线程执行。
sleep(): 调整Java执行时间,所需参数是指定线程的睡眠时间,以毫秒为单位。
join():调用线程等待本线程执行结束。
yield():暂停调度线程并将其放在等待队列末尾,等待下一轮执行,使同优先级的 其它线程有机会执行 。
isAlive():判断线程目前是否正在执行状态中
线程处于“新建”状态时,线程调用方法返回false。
当一个线程调用start()方法,并占有CUP资源后,该线程的run方法就开始运行,在线程的run方法结束之前,即没有进入死亡状态之前,线程调用isAlive()方法返回true。
当线程进入“死亡”状态后(实体内存被释放),线程仍可以调用方法isAlive(),这时返回的值是false。
相关文章推荐
- 线程的基本概念
- 什么是多线程?(线程的基本概念)
- 线程的基本概念和操作
- day10 反射创建数组 线程的基本概念 线程的编写和启动方式 线程的运行状态以及状态转换方法 线程的调度和优先级设置
- 线程的基本概念、线程的基本状态以及状态之间的关系
- java 线程基本概念 可见性 同步
- 线程的基本概念
- Linux多线程实践(一)线程基本概念和理论
- Java - 线程基本概念
- Android的四个基本概念(线程通信和GLSurfaceView)
- J2SE第九章——线程的基本概念与描述
- 线程的基本概念
- 操作系统(7)--进程、线程基本概念
- Java千百问_01基本概念(007)_线程的状态有哪些
- 基于线程、并发的基本概念(详解)
- 多线程的基本概念和Delphi线程对象Tthread介绍
- Android基本概念: 应用, 任务, 进程, 和线程
- 线程的基本概念
- 线程基本概念
- 【java多线程与并发库】---传统java多线程<1>线程基本概念