多线程常用方法

原创

海源溪 2012-07-10 22:29:34 博主文章分类：Java ©著作权

©著作权归作者所有：来自51CTO博客作者海源溪的原创作品，请联系作者获取转载授权，否则将追究法律责任

1.取得当前线程名称-----currentThread() 返回对当前正在执行的线程对象的引用。

2.设置线程的名称-----

class MyThread implements Runnable{  // 实现Runnable接口
  public void run(){  // 覆写run()方法
    for(int i=0;i<3;i++){
      System.out.println(Thread.currentThread().getName()
          + "运行，i = " + i) ;  // 取得当前线程的名字
    }
  }
};
public class ThreadNameDemo{
  public static void main(String args[]){
    MyThread mt = new MyThread() ;  // 实例化Runnable子类对象
    new Thread(mt).start() ;    // 系统自动设置线程名称
    new Thread(mt,"线程-A").start() ;    // 手工设置线程名称
    new Thread(mt,"线程-B").start() ;    // 手工设置线程名称
    new Thread(mt).start() ;    // 系统自动设置线程名称
    new Thread(mt).start() ;    // 系统自动设置线程名称
  }
};

3.判断线程是否启动----isAlive() 测试线程是否处于活动状态。

class MyThread implements Runnable{  // 实现Runnable接口
  public void run(){  // 覆写run()方法
    for(int i=0;i<3;i++){
      System.out.println(Thread.currentThread().getName()
          + "运行，i = " + i) ;  // 取得当前线程的名字
    }
  }
};
public class ThreadAliveDemo{
  public static void main(String args[]){
    MyThread mt = new MyThread() ;  // 实例化Runnable子类对象
    Thread t = new Thread(mt,"线程");    // 实例化Thread对象
    System.out.println("线程开始执行之前 --> " + t.isAlive()) ;    // 判断是否启动
    t.start() ;  // 启动线程
    System.out.println("线程开始执行之后 --> " + t.isAlive()) ;    // 判断是否启动
    for(int i=0;i<3;i++){
      System.out.println(" main运行 --> " + i) ;
    }
    // 以下的输出结果不确定
    System.out.println("代码执行之后 --> " + t.isAlive()) ;    // 判断是否启动

  }
};

4线程的强制运行----join() 等待该线程终止

class MyThread implements Runnable{  // 实现Runnable接口
  public void run(){  // 覆写run()方法
    for(int i=0;i<50;i++){
      System.out.println(Thread.currentThread().getName()
          + "运行，i = " + i) ;  // 取得当前线程的名字
    }
  }
};
public class ThreadJoinDemo{
  public static void main(String args[]){
    MyThread mt = new MyThread() ;  // 实例化Runnable子类对象
    Thread t = new Thread(mt,"线程");    // 实例化Thread对象
    t.start() ;  // 启动线程
    for(int i=0;i<50;i++){
      if(i>10){
        try{
          t.join() ;  // 线程强制运行
        }catch(InterruptedException e){}
      }
      System.out.println("Main线程运行 --> " + i) ;
    }
  }
};

5.线程休眠-----sleep(long millis)
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。sleep(long millis, int nanos)
在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

class MyThread implements Runnable{  // 实现Runnable接口
  public void run(){  // 覆写run()方法
    for(int i=0;i<50;i++){
      try{
          Thread.sleep(500) ;  // 线程休眠
      }catch(InterruptedException e){}
      System.out.println(Thread.currentThread().getName()
          + "运行，i = " + i) ;  // 取得当前线程的名字
    }
  }
};
public class ThreadSleepDemo{
  public static void main(String args[]){
    MyThread mt = new MyThread() ;  // 实例化Runnable子类对象
    Thread t = new Thread(mt,"线程");    // 实例化Thread对象
    t.start() ;  // 启动线程
  }
};

6.线程的中断----isInterrupted() 测试线程是否已经中断。

class MyThread implements Runnable{  // 实现Runnable接口
  public void run(){  // 覆写run()方法
    System.out.println("1、进入run()方法") ;
    try{
        Thread.sleep(10000) ;  // 线程休眠10秒
        System.out.println("2、已经完成了休眠") ;
    }catch(InterruptedException e){
      System.out.println("3、休眠被终止") ;
      return ; // 返回调用处
    }
    System.out.println("4、run()方法正常结束") ;
  }
};
public class ThreadInterruptDemo{
  public static void main(String args[]){
    MyThread mt = new MyThread() ;  // 实例化Runnable子类对象
    Thread t = new Thread(mt,"线程");    // 实例化Thread对象
    t.start() ;  // 启动线程
    try{
        Thread.sleep(2000) ;  // 线程休眠2秒
    }catch(InterruptedException e){
      System.out.println("3、休眠被终止") ;
    }
    t.interrupt() ;  // 中断线程执行
  }
};

7.设置后台线程-----setDaemon(boolean on) 将该线程标记为守护线程或用户线程。

class MyThread implements Runnable{  // 实现Runnable接口
  public void run(){  // 覆写run()方法
    while(true){
      System.out.println(Thread.currentThread().getName() + "在运行。") ;
    }
  }
};
public class ThreadDaemonDemo{
  public static void main(String args[]){
    MyThread mt = new MyThread() ;  // 实例化Runnable子类对象
    Thread t = new Thread(mt,"线程");    // 实例化Thread对象
    t.setDaemon(true) ;  // 此线程在后台运行
    t.start() ;  // 启动线程
  }
};

8.线程的优先级-----setPriority(int newPriority) 更改线程的优先级。

class MyThread implements Runnable{  // 实现Runnable接口
  public void run(){  // 覆写run()方法
    for(int i=0;i<5;i++){
      try{
          Thread.sleep(500) ;  // 线程休眠
      }catch(InterruptedException e){}
      System.out.println(Thread.currentThread().getName()
          + "运行，i = " + i) ;  // 取得当前线程的名字
    }
  }
};
public class ThreadPriorityDemo{
  public static void main(String args[]){
    Thread t1 = new Thread(new MyThread(),"线程A") ;  // 实例化线程对象
    Thread t2 = new Thread(new MyThread(),"线程B") ;  // 实例化线程对象
    Thread t3 = new Thread(new MyThread(),"线程C") ;  // 实例化线程对象
    t1.setPriority(Thread.MIN_PRIORITY) ;  // 优先级最低
    t2.setPriority(Thread.MAX_PRIORITY) ;  // 优先级最低
    t3.setPriority(Thread.NORM_PRIORITY) ;  // 优先级最低
    t1.start() ;  // 启动线程
    t2.start() ;  // 启动线程
    t3.start() ;  // 启动线程
  }
};

9.主方法的优先级-----Thread.currentThread().getPriority()) ;

public class MainPriorityDemo{
  public static void main(String args[]){
    System.out.println("主方法的优先级：" +
      Thread.currentThread().getPriority()) ;  // 取得主方法的优先级
    System.out.println("MAX_PRIORITY = " + Thread.MAX_PRIORITY) ;
    System.out.println("NORM_PRIORITY = " + Thread.NORM_PRIORITY) ;
    System.out.println("MIN_PRIORITY = " + Thread.MIN_PRIORITY) ;
  }
};

10.线程的礼让-----yield() 暂停当前正在执行的线程对象，并执行其他线程。

class MyThread implements Runnable{  // 实现Runnable接口
  public void run(){  // 覆写run()方法
    for(int i=0;i<5;i++){
      try{
        Thread.sleep(500) ;
      }catch(Exception e){}
      System.out.println(Thread.currentThread().getName()
          + "运行，i = " + i) ;  // 取得当前线程的名字
      if(i==2){
        System.out.print("线程礼让：") ;
        Thread.currentThread().yield() ;  // 线程礼让
      }
    }
  }
};
public class ThreadYieldDemo{
  public static void main(String args[]){
    MyThread my = new MyThread() ;  // 实例化MyThread对象
    Thread t1 = new Thread(my,"线程A") ;
    Thread t2 = new Thread(my,"线程B") ;
    t1.start() ;
    t2.start() ;
  }
};