J2SE复习笔记2--线程

 

Thread.currentThread().isInterrupted()//检查当前进程是否处于非中断状态

进程是个静态的概念,平时说的进程的执行指的是进程里面的主线程的执行;在我们的机器里面实际运行的都是线程。

 

 

1、实现Runnable接口的多线程例子
/**
* 实现Runnable接口的类
*
* @author leizhimin 2008-9-13 18:12:10
*/

public class DoSomething implements Runnable {
     private String name;

     public DoSomething(String name) {
         this.name = name;
    }

     public void run() {
         for ( int i = 0; i < 5; i++) {
             for ( long k = 0; k < 100000000; k++) ;
            System.out.println(name + ": " + i);
        }
    }
}
 
/**
* 测试Runnable类实现的多线程程序
*
* @author leizhimin 2008-9-13 18:15:02
*/

public class TestRunnable {
     public static void main(String[] args) {
        DoSomething ds1 = new DoSomething( "阿三");
        DoSomething ds2 = new DoSomething( "李四");

        Thread t1 = new Thread(ds1);
        Thread t2 = new Thread(ds2);

        t1.start();
        t2.start();
    }
}
 
执行结果:
李四: 0
阿三: 0
李四: 1
阿三: 1
李四: 2
李四: 3
阿三: 2
李四: 4
阿三: 3
阿三: 4

Process finished with exit code 0
 
2、扩展Thread类实现的多线程例子
 
/**
* 测试扩展Thread类实现的多线程程序
*
* @author leizhimin 2008-9-13 18:22:13
*/

public class TestThread extends Thread{
     public TestThread(String name) {
         super(name);
    }

     public void run() {
         for( int i = 0;i<5;i++){
             for( long k= 0; k <100000000;k++);
            System.out.println( this.getName()+ " :"+i);
        }
    }

     public static void main(String[] args) {
        Thread t1 = new TestThread( "阿三");
        Thread t2 = new TestThread( "李四");
        t1.start();
        t2.start();
    }
}
 
执行结果:
阿三 :0
李四 :0
阿三 :1
李四 :1
阿三 :2
李四 :2
阿三 :3
阿三 :4
李四 :3
李四 :4

Process finished with exit code 0

 

 

 

 

线程的状态转换是线程控制的基础。线程状态总的可分为五大状态:分别是生、死、可运行、运行、等待/阻塞。用一个图来描述如下:
 
J2SE复习笔记2--线程

 

1、新状态:线程对象已经创建,还没有在其上调用start()方法。
 
2、可运行状态:当线程准备就绪,进入排队等待CPU分配时间片的状态。当start()方法调用时,线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后,也返回到可运行状态。
 
3、运行状态:CPU从排队等待的线程中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。
 
4、等待/阻塞/睡眠状态:这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种,其共同点是:线程仍旧是活的,但是当前没有条件运行。换句话说,它是可运行的,但是如果某件事件出现,他可能返回到可运行状态。
 
5、死亡态:当线程的run()方法完成时就认为它死去。这个线程对象也许是活的,但是,它已经不是一个单独执行的线程。线程一旦死亡,就不能复生。 如果在一个死去的线程上调用start()方法,会抛出java.lang.IllegalThreadStateException异常。

 

 

 

Java线程:线程的调度-休眠

 

线程休眠的目的是使线程让出CPU的最简单的做法之一,线程休眠时候,会将CPU资源交给其他线程,以便能轮换执行,当休眠一定时间后,线程会苏醒,进入准备状态等待执行。线程睡眠到期自动苏醒,并返回到可运行状态,不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此,sleep()方法不能保证该线程睡眠到期后就开始执行。
 
线程休眠的方法是Thread.sleep(long millis) 和Thread.sleep(long millis, int nanos) ,均为静态方法,那调用sleep休眠的哪个线程呢?简单说,哪个线程调用sleep,就休眠哪个线程。
 
Java线程:线程的调度-让步
 
线程的让步含义就是使当前运行着线程让出CPU资源,但是然给谁不知道,仅仅是让出,线程状态回到可运行状态。
 
线程的让步使用Thread.yield()方法,yield() 为静态方法,功能是暂停当前正在执行的线程对象,并执行其他线程。
 
Java线程:线程的调度-合并
 
线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行,应用场景是当一个线程必须等待另一个线程执行完毕才能执行时可以使用join方法。
**  
*  Java线程:线程的调度 - 合并 
*  
*  @author leizhimin  2009 - 11 - 4   9 : 02 : 40  
*/  
public   class  Test { 
        
public   static   void  main(String[] args) { 
                Thread t1 
=   new  MyThread1(); 
                t1.start(); 

                
for  ( int  i  =   0 ; i  <   20 ; i ++ ) { 
                        System.out.println(
" 主线程第 "   +  i  +   " 次执行! " ); 
                        
if  (i  >   2 try  { 
                                
// t1线程合并到主线程中,主线程停止执行过程,转而执行t1线程,直到t1执行完毕后继续。 
                                t1.join(); 
                        } 
catch  (InterruptedException e) { 
                                e.printStackTrace(); 
                        } 
                } 
        } 


class  MyThread1  extends  Thread { 
        
public   void  run() { 
                
for  ( int  i  =   0 ; i  <   10 ; i ++ ) { 
                        System.out.println(
" 线程1第 "   +  i  +   " 次执行! " ); 
                } 
        } 

 

 
主线程第0次执行!
主线程第1次执行!
主线程第2次执行!
线程1第0次执行!
主线程第3次执行!
线程1第1次执行!
线程1第2次执行!
线程1第3次执行!
线程1第4次执行!
线程1第5次执行!
线程1第6次执行!
线程1第7次执行!
线程1第8次执行!
线程1第9次执行!
主线程第4次执行!
主线程第5次执行!
主线程第6次执行!
主线程第7次执行!
主线程第8次执行!
主线程第9次执行!
主线程第10次执行!
主线程第11次执行!
主线程第12次执行!
主线程第13次执行!
主线程第14次执行!
主线程第15次执行!
主线程第16次执行!
主线程第17次执行!
主线程第18次执行!
主线程第19次执行!

 

 

小结
到目前位置,介绍了线程离开运行状态的3种方法:
1、调用Thread.sleep():使当前线程睡眠至少多少毫秒(尽管它可能在指定的时间之前被中断)。
2、调用Thread.yield():不能保障太多事情,尽管通常它会让当前运行线程回到可运行性状态,使得有相同优先级的线程有机会执行。
3、调用join()方法:保证当前线程停止执行,直到该线程所加入的线程完成为止。然而,如果它加入的线程没有存活,则当前线程不需要停止。
4。当线程的run()方法完成。线程也会离开运行状态;
 
 
Java线程:线程的同步-同步方法
 
线程的同步是保证多线程安全访问竞争资源的一种手段。

 

public   class  TestSync  implements  Runnable
{
 Timer timer 
= new  Timer();
 
public   static   void  main(String[] args)
   {
     TestSync test 
= new  TestSync();
   
// 这里2个线程里面传入的是同一个对象test,test对象里面的包含的也是同一个timer对象;
     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   void  add(String name)
 {
 
synchronized ( this )
  { 
    num
++ ;
    
try {Thread.sleep( 1 );}
    
catch (InterruptedException e){}
    System.out.println(name
+ " ,你是第 " + num + " 个使用timer的线程 " );
  }
 }

}

 

 

在使用synchronized关键字时候,应该尽可能避免在synchronized方法或synchronized块中使用sleep或者yield方法,因为synchronized程序块占有着对象锁,你休息那么其他的线程只能一边等着你醒来执行完了才能执行。不但严重影响效率,也不合逻辑。

 

 

你可能感兴趣的:(J2SE)