- 浏览: 169637 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
静夜独窗:
有体会才真正明白
java break -
流浪若相惜:
你说的是在html文件吧?
如何在jsp文件中引入css和js文件 -
copyday:
really girl ??
showModalDialog用法 -
发呆的驴:
...
js中的push和join方法 -
itway:
thanks
JSP向后台传递参数的四种方式
线程:
是一个程序内部的顺序控制流(一个程序里面,不同的执行路径,每个执行路径代表一个线程)
main方法叫做主线程
进程:
进程只是一个静态的概念(机器上的一个class文件,机器上的一个ext文件 这叫做一个进程)平常所说的进程执行指的是进程里面主线程的执行了,main方法开始执行了
在我们机器里面实际运行的都是线程
cpu的速度比较快,它把自己的时间分成一个一个的小时间片,实际上在同一个时间点上只有一个线程在执行
java的线程是通过java.lang.Thread类来实现的,每一个Thread对象代表一个新的线程。
1.可以通过创建Thread的实例来创建新的线程
每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的
方法run()称为线程体
通过调用Tread类的start()方法来启动一个线程
2.实现Runnable接口
可以有两种方式创建新的线程
1.
定义线程类实现Runnable接口
使用Runnable接口可以为多个线程提供共享的数据
public class TestThread1 {
public static void main(String args[]) {
Runner1 r = new Runner1();
Thread t = new Thread(r);
//r.run()如果 用r.run代替t.start() r.run是方法的调用
不会产生分支,只会顺序执行。
t.start(); //本来是顺序执行的,但是t.start()代表开始了另一个分支,开始另一个线程了,main()方法自己开始往下执行,他们两个在并行运行,你输出一会儿,我输出一会儿。
for(int i=0; i<100; i++) {
System.out.println("Main Thread:------" + i);
}
}
}
class Runner1 implements Runnable {
public void run() { //要执行的东西
for(int i=0; i<100; i++) {
System.out.println("Runner1 :" + i);
}
}
}
2.可以定义一个Thread的子类并重写其run方法
然后生成该类的对象
public class TestThread1 {
public static void main(String args[]) {
Runner1 r = new Runner1();
r.start();
for(int i=0; i<100; i++) {
System.out.println("Main Thread:------" + i);
}
}
}
class Runner1 extends Thread {
public void run() {
for(int i=0; i<100; i++) {
System.out.println("Runner1 :" + i);
}
}
}
线程优先级越高的线程,获得cpu执行的时间就越多
线程同步:
public class TestSync implements Runnable {
Timer timer = new Timer();
public static void main(String[] args) {
TestSync test = new TestSync();
Thread t1 = new Thread(test);
Thread t2 = new Thread(test);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
public void run(){
timer.add(Thread.currentThread().getName());
}
}
class Timer{
private static int num = 0;
public synchronized void add(String name){ //第一种方式
//synchronized (this) { //第二种方式 代表锁定当前对象 只有一个线程能访问这个方法
num ++;
try {Thread.sleep(1);}
catch (InterruptedException e) {}
System.out.println(name+", 你是第"+num+"个使用timer的线程");
//}
}
}
JAVA多线程机制
程序、进程和线程:
程序是一段静态的代码,它是应用程序执行的蓝本。进程是程序的一次动态执行过程,它对应了从代码加载、执行至执行完毕的一个完整过程,这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位,一个进程执行过程中可以产生多个线程,每个线程有自身的产生、存在和消亡的过程,也是一个动态的概念。每个进程都有一段专用的内存区域,而线程间可以共享相同的内存区域(包括代码和数据),并利用这些共享单元来实现数据交换、实时通信与必要的同步操作。
每个Java程序都有一个默认的主线程。Java程序总是从主类的main方法开始执行。当JVM加载代码,发现main方法后就启动一个线程,这个线程就称作"主线程",该线程负责执行main方法。在main方法中再创建的线程就是其他线程。
如果main方法中没有创建其他线程,那么当main方法返回时JVM就会结束Java应用程序。但如果main方法中创建了其他线程,那么JVM就要在主线程和其他线程之间轮流切换,保证每个线程都有机会使用CPU资源,main方法返回(主线程结束)JVM也不会结束,要一直等到该程序所有线程全部结束才结束Java程序(另外一种情况是:程序中调用了Runtime类的exit方法,并且安全管理器允许退出操作发生。这时JVM也会结束该程序)。
线程的状态与生命周期:
Java使用java.lang.Thread类及其子类的对象表示线程,新建的线程在它的一个完整生命周期中通常要经历如下四种状态:(新建、运行、(中断/挂起/阻塞)、消亡)
1、新建:
当一个Thread类或其子类对象被声明并创建,新生的线程对象就处于新建状态(此时它已经有了内存空间和其他资源)。
2、运行:
线程已经创建就具备了运行的条件,一旦轮到它来享用CPU资源时,即JVM将CPU使用权切换给该线程时,此线程就可以脱离创建它的主线程独立开始自己的生命周期了。
线程创建后仅仅是占有了内存资源,在JVM管理的线程中还没有这个线程,此线程必须调用start()方法(从父类继承)通知JVM,这样JVM就知道又有一个新的线程排队等候切换。
当JVM将CPU使用权切换给线程时,如果线程是Thread的子类创建的,该类中的run()方法立刻执行(run()方法中规定了该线程的具体使命)。Thread类中的run()方法没有具体内容,程序要在Thread类的子类中重写run()方法覆盖父类该方法。(注意:在线程没有结束run()方法前,不要再调用start方法,否则将发生ILLegalThreadStateException异常)
3、挂起:
线程挂起的原因有一下四种:
(1)、JVM将CPU资源从当前线程切换给其他线程,使本线程让出CPU的使用权,并处于挂起状态。
(2)、线程使用CPU资源期间,执行了sleep(int millsecond)方法,使当前线程进入休眠状态。sleep(int millsecond)方法是Thread类中的一个类方法,线程执行该方法就立刻让出CPU使用权,进入挂起状态。经过参数millsecond指定的毫秒数之后,该线程就重新进到线程队列中排队等待CPU资源,然后从中断处继续运行。
(3)、线程使用CPU资源期间,执行了wait()方法,使得当前线程进入等待状态。等待状态的线程不会主动进入线程队列等待CPU资源,必须由其他线程调用notify()方法通知它,才能让该线程从新进入到线程队列中排队等待CPU资源,以便从中断处继续运行。
(4)、线程使用CPU资源期间,执行某个操作进入阻塞状态,如执行读/写操作引起阻塞。进入阻塞状态时线程不能进入线程队列,只有引起阻塞的原因消除时,线程才能进入到线程队列排队等待CPU资源,以便从中断处继续运行。
4、死亡:
死亡状态就是线程释放了实体,即释放了分配给线程对象的内存。线程死亡的原因有两个:
(1)、正常运行的线程完成了它的全部工作,即执行完run()方法中的全部语句,结束了run()方法。
(2)、线程被提前强制性终止,即强制run()方法结束。
线程调度与优先级:
JVM的线程调度器负责管理线程,调度器把线程的优先级分为10个级别,分别用Thread类中的类常量表示。每个Java线程的优先级都在常数1-10之间。Thread类优先级常量有三个:
static int MIN_PRIORITY //1
static int NORM_PRIORITY //5
static int MAX_PRIORITY //10
如果没有明确设置,默认线程优先级为常数5即Thread.NORM_PRIORITY。
线程优先级可以用setPriority(int grade)方法调整,如果参数grade不在1-10范围内,那么setPriority产生一个IllegalArgumenException异常。用getPriority()方法返回线程优先级。(注意:有些操作系统只能识别3个级别:1、5、10)
Java调度器的任务是使优先级高的线程能始终运行,一旦时间片有空闲,则使具有同等优先级的线程以轮流的方式顺序使用时间片。只有当高级别的线程死亡时(除非用sleep(int millsecond)或wait()方法让出CPU资源),低级别线程才有机会获得CPU资源。
实际编程时,不提倡使用线程的优先级来保证算法的正确执行。要编写正确、跨平台的多线程代码,必须假设线程在任何时刻都有可能被剥夺CPU资源的使用权。
Java中实现多线程有两种方法:
1、继承Thread类,覆盖run()方法:使用Thread子类创建线程的优点是可以在子类中增加新的成员变量或方法,使线程具有某种属性或功能。但Java不支持多继承,Thread类的子类不能再扩展其他的类。
2、实现Runnable接口:用Thread类直接创建线程对象,使用构造函数Thread(Runnable target)(参数target是一个Runnable接口),创建线程对象时必须向构造方法参数传递一个实现Runnable接口类的实例,该实例对象称作所创线程的目标对象。当线程调用start()方法,一旦轮到它使用CPU资源,目标对象自动调用接口中的run()方法(接口回调)。
线程间可以共享相同的内存单元(包括代码和数据),并利用这些共享单元来实现数据交换、实时通信与必要的同步操作。对于Thread(Runnable target)创建的使用同一目标对象的线程,可以共享该目标对象的成员变量和方法。
另外,创建目标对象类在必要时还可以是某个特定类的子类,因此,使用Runnable接口比使用Thread的子类更具有灵活性。
(注意:具有相同目标对象的线程,run()方法中的局部变量相互独立,互不干扰)
在线程中启动其他线程,当线程调用start()方法启动,使之从新建态进入就绪队列,一旦得到CPU资源就脱离创建它的主线程,开始自己的生命周期。
线程的常用方法:
start():线程调用该方法将启动线程,从新建态进入就绪队列,一旦享用CPU资源就可以脱离创建它的线程,独立开始自己的生命周期。
run():Thread类的run()方法与Runnable接口中的run()方法功能和作用相同,都用来定义线程对象被调度后所进行的操作,都是系统自动调用而用户不得引用的方法。run()方法执行完毕,线程就成死亡状态,即线程释放了分配给它的内存(死亡态线程不能再调用start()方法)。在线程没有结束run()方法前,不能让线程再调用start()方法,否则将发生IllegalThreadStateException异常。
sleep(int millsecond):有时,优先级高的线程需要优先级低的线程做一些工作来配合它,此时为让优先级高的线程让出CPU资源,使得优先级低的线程有机会运行,可以使用sleep(int millsecond)方法。线程在休眠时被打断,JVM就抛出InterruptedException异常。因此,必须在try-catch语句块中调用sleep方法。
isAlive():当线程调用start()方法并占有CPU资源后该线程的run()方法开始运行,在run()方法没有结束之前调用isAlive()返回true,当线程处于新建态或死亡态时调用isAlive()返回false。
注意:一个已经运行的线程在没有进入死亡态时,不要再给它分配实体,由于线程只能引用最后分配的实体,先前的实体就成为了"垃圾",并且不能被垃圾回收机制收集。
currentThread():是Thread类的类方法,可以用类名调用,返回当前正在使用CPU资源的线程。
interrupt():当线程调用sleep()方法处于休眠状态,一个占有CPU资源的线程可以让休眠的线程调用interrupt()方法"吵醒"自己,即导致线程发生IllegalThreadStateException异常,从而结束休眠,重新排队等待CPU资源。
GUI线程:JVM在运行包含图形界面应用程序时,会自动启动更多线程,其中有两个重要的线程:AWT-EventQueue和AWT-Windows。AWT-EventQueue线程负责处理GUI事件,AWT-Windows线程负责将窗体或组件绘制到桌面。
线程同步:(用synchronized修饰某个方法,该方法修改需要同步的变量;或用volatile修饰基本变量)
当两个或多个线程同时访问一个变量,并且一个线程需要修改这个变量时,应对这样的问题进行处理,否则可能发生混乱。
要处理线程同步,可以把修改数据的方法用关键字synchronized修饰。一个方法使用synchronized修饰,当一个线程A使用这个方法时,其他线程想使用该方法时就必须等待,直到线程A使用完该方法。所谓同步就是多个线程都需要使用一个synchronized修饰的方法。
volatile比同步简单,只适合于控制对基本变量(整数、布尔变量等)的单个实例的访问。java中的volatile关键字与C++中一样,用volatile修饰的变量在读写操作时不会进行优化(取cache里的值以提高io速度),而是直接对主存进行操作,这表示所有线程在任何时候看到的volatile变量值都相同。
在同步方法中使用wait()、notify()、notifyAll()方法:
当一个线程使用的同步方法中用到某个变量,而此变量又需要其他线程修改后才能符合本线程需要,那么可以在同步方法中使用wait()方法。中断方法的执行,使本线程等待,暂时让出CPU资源,并允许其他线程使用这个同步方法。其他线程如果在使用这个同步方法时不需要等待,那么它使用完这个同步方法时应当用notifyAll()方法通知所有由于使用这个同步方法而处于等待的线程结束等待。曾中断的线程就会从中断处继续执行,并遵循"先中断先继续"的原则。如果用的notify()方法,那么只是通知等待中的线程中某一个结束等待。
计时器线程Timer:(Timer还有很多高级操作,详细见JDK,这里做个概述)
java.swing.Timer类用于周期性地执行某些操作。有两个常用构造函数
public Timer(int delay, ActionListener listener):参数listener是计时器的监视器,计时器发生振铃的事件是ActionEvent类型事件,当振铃事件发生,监视器会监视到这个事件并回调ActionListener接口中的actionPerformed(ActionEvent e)方法。
public Timer(int delay):使用该构造方法,计时器要再调用addActionListener(ActionListener listener)方法获得监视器。
如果想让计时器只震动一次,可以让计时器调用setRepeats(boolean b)方法,参数b取false即可。
计时器还可以调用setInitialDelay(int delay)方法设置首次振铃的延时,如果没有设置首次振铃默认延时为构造函数中的参数delay。
还可以调用getDelay()和setDelay(int delay)获取和设置延时。
计时器创建后调用start()启动,调用stop()停止,即挂起,调用restart()重新启动计时器,即恢复线程。
线程联合:
一个线程A在占有CPU资源期间,可以让其他线程调用join()方法和本线程联合,如:
B.join();
此时称A在运行期间联合了B。这时A线程立刻终端执行,一直等到它联合的线程B执行完毕,A线程再重新排队等待CPU资源。但如果A准备联合的线程B已经结束,则B.join()不会产生任何效果。
守护线程:
线程默认是非守护线程,非守护线程也称用户线程,一个线程调用setDaemon(boolean on)方法可以将自己设置成一个守护(Daemon)线程,如:
thread.setDaemon(true);
一个线程必须在自己运行之前设置自己是否是守护线程。守护线程是当程序中所有用户线程都已结束运行时即使守护线程的run()方法还有需要执行的语句,守护线程也会立刻结束运行。因此守护线程用于做一些不是很严格的工作,当线程随时结束时不会产生什么不良后果。
本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx
是一个程序内部的顺序控制流(一个程序里面,不同的执行路径,每个执行路径代表一个线程)
main方法叫做主线程
进程:
进程只是一个静态的概念(机器上的一个class文件,机器上的一个ext文件 这叫做一个进程)平常所说的进程执行指的是进程里面主线程的执行了,main方法开始执行了
在我们机器里面实际运行的都是线程
cpu的速度比较快,它把自己的时间分成一个一个的小时间片,实际上在同一个时间点上只有一个线程在执行
java的线程是通过java.lang.Thread类来实现的,每一个Thread对象代表一个新的线程。
1.可以通过创建Thread的实例来创建新的线程
每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的
方法run()称为线程体
通过调用Tread类的start()方法来启动一个线程
2.实现Runnable接口
可以有两种方式创建新的线程
1.
定义线程类实现Runnable接口
使用Runnable接口可以为多个线程提供共享的数据
public class TestThread1 {
public static void main(String args[]) {
Runner1 r = new Runner1();
Thread t = new Thread(r);
//r.run()如果 用r.run代替t.start() r.run是方法的调用
不会产生分支,只会顺序执行。
t.start(); //本来是顺序执行的,但是t.start()代表开始了另一个分支,开始另一个线程了,main()方法自己开始往下执行,他们两个在并行运行,你输出一会儿,我输出一会儿。
for(int i=0; i<100; i++) {
System.out.println("Main Thread:------" + i);
}
}
}
class Runner1 implements Runnable {
public void run() { //要执行的东西
for(int i=0; i<100; i++) {
System.out.println("Runner1 :" + i);
}
}
}
2.可以定义一个Thread的子类并重写其run方法
然后生成该类的对象
public class TestThread1 {
public static void main(String args[]) {
Runner1 r = new Runner1();
r.start();
for(int i=0; i<100; i++) {
System.out.println("Main Thread:------" + i);
}
}
}
class Runner1 extends Thread {
public void run() {
for(int i=0; i<100; i++) {
System.out.println("Runner1 :" + i);
}
}
}
线程优先级越高的线程,获得cpu执行的时间就越多
线程同步:
public class TestSync implements Runnable {
Timer timer = new Timer();
public static void main(String[] args) {
TestSync test = new TestSync();
Thread t1 = new Thread(test);
Thread t2 = new Thread(test);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
public void run(){
timer.add(Thread.currentThread().getName());
}
}
class Timer{
private static int num = 0;
public synchronized void add(String name){ //第一种方式
//synchronized (this) { //第二种方式 代表锁定当前对象 只有一个线程能访问这个方法
num ++;
try {Thread.sleep(1);}
catch (InterruptedException e) {}
System.out.println(name+", 你是第"+num+"个使用timer的线程");
//}
}
}
JAVA多线程机制
程序、进程和线程:
程序是一段静态的代码,它是应用程序执行的蓝本。进程是程序的一次动态执行过程,它对应了从代码加载、执行至执行完毕的一个完整过程,这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位,一个进程执行过程中可以产生多个线程,每个线程有自身的产生、存在和消亡的过程,也是一个动态的概念。每个进程都有一段专用的内存区域,而线程间可以共享相同的内存区域(包括代码和数据),并利用这些共享单元来实现数据交换、实时通信与必要的同步操作。
每个Java程序都有一个默认的主线程。Java程序总是从主类的main方法开始执行。当JVM加载代码,发现main方法后就启动一个线程,这个线程就称作"主线程",该线程负责执行main方法。在main方法中再创建的线程就是其他线程。
如果main方法中没有创建其他线程,那么当main方法返回时JVM就会结束Java应用程序。但如果main方法中创建了其他线程,那么JVM就要在主线程和其他线程之间轮流切换,保证每个线程都有机会使用CPU资源,main方法返回(主线程结束)JVM也不会结束,要一直等到该程序所有线程全部结束才结束Java程序(另外一种情况是:程序中调用了Runtime类的exit方法,并且安全管理器允许退出操作发生。这时JVM也会结束该程序)。
线程的状态与生命周期:
Java使用java.lang.Thread类及其子类的对象表示线程,新建的线程在它的一个完整生命周期中通常要经历如下四种状态:(新建、运行、(中断/挂起/阻塞)、消亡)
1、新建:
当一个Thread类或其子类对象被声明并创建,新生的线程对象就处于新建状态(此时它已经有了内存空间和其他资源)。
2、运行:
线程已经创建就具备了运行的条件,一旦轮到它来享用CPU资源时,即JVM将CPU使用权切换给该线程时,此线程就可以脱离创建它的主线程独立开始自己的生命周期了。
线程创建后仅仅是占有了内存资源,在JVM管理的线程中还没有这个线程,此线程必须调用start()方法(从父类继承)通知JVM,这样JVM就知道又有一个新的线程排队等候切换。
当JVM将CPU使用权切换给线程时,如果线程是Thread的子类创建的,该类中的run()方法立刻执行(run()方法中规定了该线程的具体使命)。Thread类中的run()方法没有具体内容,程序要在Thread类的子类中重写run()方法覆盖父类该方法。(注意:在线程没有结束run()方法前,不要再调用start方法,否则将发生ILLegalThreadStateException异常)
3、挂起:
线程挂起的原因有一下四种:
(1)、JVM将CPU资源从当前线程切换给其他线程,使本线程让出CPU的使用权,并处于挂起状态。
(2)、线程使用CPU资源期间,执行了sleep(int millsecond)方法,使当前线程进入休眠状态。sleep(int millsecond)方法是Thread类中的一个类方法,线程执行该方法就立刻让出CPU使用权,进入挂起状态。经过参数millsecond指定的毫秒数之后,该线程就重新进到线程队列中排队等待CPU资源,然后从中断处继续运行。
(3)、线程使用CPU资源期间,执行了wait()方法,使得当前线程进入等待状态。等待状态的线程不会主动进入线程队列等待CPU资源,必须由其他线程调用notify()方法通知它,才能让该线程从新进入到线程队列中排队等待CPU资源,以便从中断处继续运行。
(4)、线程使用CPU资源期间,执行某个操作进入阻塞状态,如执行读/写操作引起阻塞。进入阻塞状态时线程不能进入线程队列,只有引起阻塞的原因消除时,线程才能进入到线程队列排队等待CPU资源,以便从中断处继续运行。
4、死亡:
死亡状态就是线程释放了实体,即释放了分配给线程对象的内存。线程死亡的原因有两个:
(1)、正常运行的线程完成了它的全部工作,即执行完run()方法中的全部语句,结束了run()方法。
(2)、线程被提前强制性终止,即强制run()方法结束。
线程调度与优先级:
JVM的线程调度器负责管理线程,调度器把线程的优先级分为10个级别,分别用Thread类中的类常量表示。每个Java线程的优先级都在常数1-10之间。Thread类优先级常量有三个:
static int MIN_PRIORITY //1
static int NORM_PRIORITY //5
static int MAX_PRIORITY //10
如果没有明确设置,默认线程优先级为常数5即Thread.NORM_PRIORITY。
线程优先级可以用setPriority(int grade)方法调整,如果参数grade不在1-10范围内,那么setPriority产生一个IllegalArgumenException异常。用getPriority()方法返回线程优先级。(注意:有些操作系统只能识别3个级别:1、5、10)
Java调度器的任务是使优先级高的线程能始终运行,一旦时间片有空闲,则使具有同等优先级的线程以轮流的方式顺序使用时间片。只有当高级别的线程死亡时(除非用sleep(int millsecond)或wait()方法让出CPU资源),低级别线程才有机会获得CPU资源。
实际编程时,不提倡使用线程的优先级来保证算法的正确执行。要编写正确、跨平台的多线程代码,必须假设线程在任何时刻都有可能被剥夺CPU资源的使用权。
Java中实现多线程有两种方法:
1、继承Thread类,覆盖run()方法:使用Thread子类创建线程的优点是可以在子类中增加新的成员变量或方法,使线程具有某种属性或功能。但Java不支持多继承,Thread类的子类不能再扩展其他的类。
2、实现Runnable接口:用Thread类直接创建线程对象,使用构造函数Thread(Runnable target)(参数target是一个Runnable接口),创建线程对象时必须向构造方法参数传递一个实现Runnable接口类的实例,该实例对象称作所创线程的目标对象。当线程调用start()方法,一旦轮到它使用CPU资源,目标对象自动调用接口中的run()方法(接口回调)。
线程间可以共享相同的内存单元(包括代码和数据),并利用这些共享单元来实现数据交换、实时通信与必要的同步操作。对于Thread(Runnable target)创建的使用同一目标对象的线程,可以共享该目标对象的成员变量和方法。
另外,创建目标对象类在必要时还可以是某个特定类的子类,因此,使用Runnable接口比使用Thread的子类更具有灵活性。
(注意:具有相同目标对象的线程,run()方法中的局部变量相互独立,互不干扰)
在线程中启动其他线程,当线程调用start()方法启动,使之从新建态进入就绪队列,一旦得到CPU资源就脱离创建它的主线程,开始自己的生命周期。
线程的常用方法:
start():线程调用该方法将启动线程,从新建态进入就绪队列,一旦享用CPU资源就可以脱离创建它的线程,独立开始自己的生命周期。
run():Thread类的run()方法与Runnable接口中的run()方法功能和作用相同,都用来定义线程对象被调度后所进行的操作,都是系统自动调用而用户不得引用的方法。run()方法执行完毕,线程就成死亡状态,即线程释放了分配给它的内存(死亡态线程不能再调用start()方法)。在线程没有结束run()方法前,不能让线程再调用start()方法,否则将发生IllegalThreadStateException异常。
sleep(int millsecond):有时,优先级高的线程需要优先级低的线程做一些工作来配合它,此时为让优先级高的线程让出CPU资源,使得优先级低的线程有机会运行,可以使用sleep(int millsecond)方法。线程在休眠时被打断,JVM就抛出InterruptedException异常。因此,必须在try-catch语句块中调用sleep方法。
isAlive():当线程调用start()方法并占有CPU资源后该线程的run()方法开始运行,在run()方法没有结束之前调用isAlive()返回true,当线程处于新建态或死亡态时调用isAlive()返回false。
注意:一个已经运行的线程在没有进入死亡态时,不要再给它分配实体,由于线程只能引用最后分配的实体,先前的实体就成为了"垃圾",并且不能被垃圾回收机制收集。
currentThread():是Thread类的类方法,可以用类名调用,返回当前正在使用CPU资源的线程。
interrupt():当线程调用sleep()方法处于休眠状态,一个占有CPU资源的线程可以让休眠的线程调用interrupt()方法"吵醒"自己,即导致线程发生IllegalThreadStateException异常,从而结束休眠,重新排队等待CPU资源。
GUI线程:JVM在运行包含图形界面应用程序时,会自动启动更多线程,其中有两个重要的线程:AWT-EventQueue和AWT-Windows。AWT-EventQueue线程负责处理GUI事件,AWT-Windows线程负责将窗体或组件绘制到桌面。
线程同步:(用synchronized修饰某个方法,该方法修改需要同步的变量;或用volatile修饰基本变量)
当两个或多个线程同时访问一个变量,并且一个线程需要修改这个变量时,应对这样的问题进行处理,否则可能发生混乱。
要处理线程同步,可以把修改数据的方法用关键字synchronized修饰。一个方法使用synchronized修饰,当一个线程A使用这个方法时,其他线程想使用该方法时就必须等待,直到线程A使用完该方法。所谓同步就是多个线程都需要使用一个synchronized修饰的方法。
volatile比同步简单,只适合于控制对基本变量(整数、布尔变量等)的单个实例的访问。java中的volatile关键字与C++中一样,用volatile修饰的变量在读写操作时不会进行优化(取cache里的值以提高io速度),而是直接对主存进行操作,这表示所有线程在任何时候看到的volatile变量值都相同。
在同步方法中使用wait()、notify()、notifyAll()方法:
当一个线程使用的同步方法中用到某个变量,而此变量又需要其他线程修改后才能符合本线程需要,那么可以在同步方法中使用wait()方法。中断方法的执行,使本线程等待,暂时让出CPU资源,并允许其他线程使用这个同步方法。其他线程如果在使用这个同步方法时不需要等待,那么它使用完这个同步方法时应当用notifyAll()方法通知所有由于使用这个同步方法而处于等待的线程结束等待。曾中断的线程就会从中断处继续执行,并遵循"先中断先继续"的原则。如果用的notify()方法,那么只是通知等待中的线程中某一个结束等待。
计时器线程Timer:(Timer还有很多高级操作,详细见JDK,这里做个概述)
java.swing.Timer类用于周期性地执行某些操作。有两个常用构造函数
public Timer(int delay, ActionListener listener):参数listener是计时器的监视器,计时器发生振铃的事件是ActionEvent类型事件,当振铃事件发生,监视器会监视到这个事件并回调ActionListener接口中的actionPerformed(ActionEvent e)方法。
public Timer(int delay):使用该构造方法,计时器要再调用addActionListener(ActionListener listener)方法获得监视器。
如果想让计时器只震动一次,可以让计时器调用setRepeats(boolean b)方法,参数b取false即可。
计时器还可以调用setInitialDelay(int delay)方法设置首次振铃的延时,如果没有设置首次振铃默认延时为构造函数中的参数delay。
还可以调用getDelay()和setDelay(int delay)获取和设置延时。
计时器创建后调用start()启动,调用stop()停止,即挂起,调用restart()重新启动计时器,即恢复线程。
线程联合:
一个线程A在占有CPU资源期间,可以让其他线程调用join()方法和本线程联合,如:
B.join();
此时称A在运行期间联合了B。这时A线程立刻终端执行,一直等到它联合的线程B执行完毕,A线程再重新排队等待CPU资源。但如果A准备联合的线程B已经结束,则B.join()不会产生任何效果。
守护线程:
线程默认是非守护线程,非守护线程也称用户线程,一个线程调用setDaemon(boolean on)方法可以将自己设置成一个守护(Daemon)线程,如:
thread.setDaemon(true);
一个线程必须在自己运行之前设置自己是否是守护线程。守护线程是当程序中所有用户线程都已结束运行时即使守护线程的run()方法还有需要执行的语句,守护线程也会立刻结束运行。因此守护线程用于做一些不是很严格的工作,当线程随时结束时不会产生什么不良后果。
本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx
发表评论
-
数组的创建方式
2013-07-20 22:28 682数组的声明: 类型标识符 数组名[ ] 或者 类型标识符[] ... -
序列化 关键字transient
2013-02-20 11:12 822在java的类中,进行序列化时,如果某个成员变量被transi ... -
java容器
2013-02-01 16:26 767import java.util.*; public cla ... -
java.lang.Enum
2013-02-01 11:45 889枚举类型在java中是作为一个类封装起来的 枚举类型: 只能 ... -
java异常处理
2013-01-30 13:09 759java程序的执行过程中如 ... -
接口特性
2013-01-29 17:16 684接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而 ... -
final关键字
2013-01-29 15:35 636final 的变量的值不能够被改变 (final的成员变量,f ... -
抽象类
2013-01-29 15:12 6311.用abstract关键字来修饰一个类时,这个类叫做抽象类, ... -
动态绑定
2013-01-29 14:29 713动态绑定/多态: 动态绑定是指在执行期间(而非编译期间)判断 ... -
对象转型
2013-01-29 11:38 689一个基类的引用类型变量可以“指向”其子类的对象 一个基类的引 ... -
方法的重写
2013-01-28 13:42 616在子类中可以根据需要对从基类中继承来的方法进行重写 重写方法必 ... -
java.lang
2013-01-25 16:41 613jdk 自动封装的包中 只有java.lang 这个包不需要引 ... -
java中重载
2013-01-25 14:18 735方法重载: 是指一个类中可以定义有相同的方法的名字,但是参数不 ... -
java 构造方法
2013-01-25 10:47 686当没有指定构造函数时,编译器为类自动添加形如 类名() {} ... -
内存分析
2013-01-25 10:27 668同一个类的每个对象有不同的成员变量存储空间 同一个类的每个对象 ... -
成员变量 和局部变量
2013-01-25 09:55 721成员变量 不赋予初值可以使用 默认会有初值 局部变量 必须赋 ... -
类和类之间的关系
2013-01-24 17:41 1418类和类之间的关系 1.泛化(继承)表示为 is-a 关系 表 ... -
java switch
2013-01-24 10:46 465多个case可以合并到一起,代笔或者的意思 java中Swit ... -
java break
2013-01-24 10:32 695breank 只能跳出一层循环 -
java格式
2013-01-23 17:40 500方法和方法之间 变量和语句之间 运算符两侧 ...
相关推荐
c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程c_多线程...
基于SpringBoot和POI实现单线程和多线程导出Excel.zip基于SpringBoot和POI实现单线程和多线程导出Excel.zip基于SpringBoot和POI实现单线程和多线程导出Excel.zip基于SpringBoot和POI实现单线程和多线程导出Excel.zip...
Qt 多线程及简单实例 demo。 多线程的几大特点: 1.多线程的执行顺序无法保证,与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高,因此对...
Qt中利用OpenCV2.4.4多线程打开多摄像机 每个线程处理一个摄像机,从中拿出帧显示到主线程的Label控件上 模拟了一个16个摄像机的场景,有不开多线程和打开多线程的对比。 可以明显感觉到打开多线程后主界面不卡了。 ...
在计算机处理器发展为包含越来越多的核心的时期,多线程是创建可伸缩性、高效的、高响应性应用程序的关键因素。如果你没有正确地使用多线程,它会导致难以捉摸的问题,需要你花费大量时间去解决。因此,现代应用程序...
最近用多线程用的比较多自己走了一些弯路,分享出来希望大家少走弯路,C#中的多线程有两个重载,一个是不带参数的,一个是带参数的,但是即便是带参数的多线程也不支持泛型,这使得使用泛型参数多线程的时候很不方便...
Win32多线程程序设计.pdf(带目录)Win32多线程程序设计.pdf(带目录)Win32多线程程序设计.pdf(带目录)Win32多线程程序设计.pdf(带目录)Win32多线程程序设计.pdf(带目录)Win32多线程程序设计.pdf(带目录)...
c语言多进程多线程编程
串口通信的实现,编程环境为C#,实现技术采用了多线程方式
Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式...
c#大漠多线程模板
Qt中利用OpenCV2.4.4多线程打开多摄像机 每个线程处理一个摄像机,从中拿出帧显示到主线程的Label控件上 模拟了一个16个摄像机的场景,有不开多线程和打开多线程的对比。 可以明显感觉到打开多线程后主界面不卡了。 ...
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化,即在一块芯片上集成多个处理器内核(Core),多核处理器(Multicore Processor)离我们越来越近了――如今...
C#.NET多线程实例6个(包括多线程基本使用,多线程互斥等全部多线程使用实例),可直接运行
多线程多线程多线程多线程多线程多线程多线程多线程多线程多线程多线程多线程多线程多线程多线程多线程多线程多线程多线程多线程多线程
是多线程的测试,对学习多线程的朋友有用,使用C#2008来编写的,需要的朋友可以去下载
java多线程PPT 多线程基本概念 创建线程的方式 线程的挂起与唤醒 多线程问题
excel vba 多线程 实例 excel vba 多线程 实例
简单多线程编程入门,可以帮助你实现第一个多线程程序
最近收集的VB.Net-C#多线程Thread-代理委托delegate编程。文章列表: c#.net多线程同步.txt C#WebBrowser页面与WinForm交互技巧一.txt C#多线程编程-多细全.txt C#多线程编程简单实例.txt C#多线程窗体控件安全访问....