线程总结(一)

时间：2014-05-17 14:16:55 阅读：472 评论：0 收藏：0 [点我收藏+]

线程：是程序的不同执行路径

一般操作系统支持多线程，多进程。dos支持单进程。

一个cpu，实质上只能支持一个线程执行，只是cpu运行速度快，看起来像是多线程。如果是双cpu或双核，可以执行多进程。

java中的线程是由java.lang.Thread类实现的

/**
 * 
 *程序功能：创建线程方法一(常用方法)
 * @author Administrator
 */
public class Test {
    //
    public static void main(String[] args) {
        // TODO Auto-generated constructor stub
        Run r=new Run();
        //通过Thread的实例化创建新的线程
        Thread t=new Thread(r);
        //启动线程，自动执行重写的run()方法
        t.start();
        
        //虚拟机启动时会自动创建一个有主方法定义的线程主线程。
        //主线程调用的方法
        for(int i=0;i<100;i++){
            System.out.println("Main Thread"+i);
            
        }
        
    }

}

//通过实现Runnable接口来重写run()方法
class Run implements Runnable{

    //启动新创建的线程时调用的方法
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<100;i++){
            System.out.println("new Thread"+i);
            
        }
        
    }
    
}

/**
 * 
 *程序功能：调用方法
 * @author Administrator
 */
public class Test2 {

    public static void main(String[] args) {
        // TODO Auto-generated constructor stub
        Run r=new Run();
        //方法调用
        r.run();
        //Thread t=new Thread(r);
        //t.start();
        
        
        for(int i=0;i<100;i++){
            System.out.println("Main Thread"+i);
            
        }

    }

}


class Run implements Runnable{

    
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<100;i++){
            System.out.println("new Thread"+i);

        }

    }

}

创建线程与方法调用区别

创建线程前，执行main方法中的语句，创建线程后，main方法未执行的语句与

创建线程后自动调用的语句并行执行，直到两者都执行完毕

方法调用前，执行main方法中的语句，执行到方法调用时，先停止执行main方法，执行调用的方法，当调用的方法执行完后，再继续执行main方法中还未执行的语句

/**
 * 
 *程序功能：创建线程方法二
 * @author Administrator
 */


public class Test2{
    public static void main(String[] args){
        Run t=new Run();
        t.start();
        
        for(int i=0;i<10;i++){
            System.out.println("主线程"+i);
        }
        
    }
}



class Run extends  Thread{
    public void run(){
        for(int i=0;i<10;i++)
        System.out.println("新线程");
    }
}

一般用方法一创建线程。因为java中的类只能继承一个类，但是可以实现很多接口

Thread类常用方法：

public static void sleep（long mills）throws InterruptedException：

使当前进程休眠（暂时停止执行mills毫秒）

在哪个线程里调用sleep方法，哪个线程陷入睡眠状态

void stop()：已过时，在需要杀死线程时使用

void interrupt()：中断线程

import java.util.Date;
/**
 * 
 *程序功能：不太合理的停止新建线程方法
 * @author Administrator
 */

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Thread t=new Thread(new Runner());
        t.start();
        try {
            //主线程睡眠10s
            t.sleep(10000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //强制打断线程运行，引发Runner类中异常
        t.interrupt();
    }

}

class Runner implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        Thread t=new Thread();
        while(true){
            System.out.println("---"+new Date()+"---");
            try {
                //睡眠1s
                t.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                return;
            }
        }
        
    }
    
    
}

/**
 * 
 *程序功能：停止创建的线程
 * @author Administrator
 */


import java.util.*;
public class Test2 {
  public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start();
    try {Thread.sleep(10000);}
    catch (InterruptedException e) {}
    thread.flag=false;
  }
}

class MyThread extends Thread {
    boolean flag = true;
  public void run(){
    while(flag){
      System.out.println("==="+new Date()+"===");
      try {
        sleep(1000);
      } catch (InterruptedException e) {
        return;
      }
    }
  }
}

import java.util.Date;

public class Test {
  public static void main(String[] args) {
      Runner r=new Runner();
      Thread t=new Thread(r);
      t.start();
      for(int i=0;i<10;i++){
          System.out.println("主线程"+i);
      }

      r.shutDown();
  }
}

class Runner implements Runnable{
    boolean flag=true;
    public void run(){
        int i=0;
        while(flag){
            System.out.println("新线程"+i++);
            
        }
    }
    public void shutDown(){
        flag=false;
    }
}

void join():合并某个线程，相当于方法调用

public class Test {
  public static void main(String[] args) {
    MyThread2 t1 = new MyThread2("abcde");
    t1.start();
    try {
        t1.join();
    } catch (InterruptedException e) {}
        
    for(int i=1;i<=10;i++){
      System.out.println("i am main thread");
    }
  }
}
class MyThread2 extends Thread {
  MyThread2(String s){
      super(s);
  }
  
  public void run(){
    for(int i =1;i<=10;i++){
      System.out.println("i am "+getName());
      try {
          sleep(1000);
      } catch (InterruptedException e) {
          return;
      }
    }
  }
}

public static void yield()：暂停当前正在执行的线程对象，并执行其他线程。

public class TestYield {
  public static void main(String[] args) {
    MyThread3 t1 = new MyThread3("t1");
    MyThread3 t2 = new MyThread3("t2");
    t1.start(); t2.start();
  }
}
class MyThread3 extends Thread {
  MyThread3(String s){super(s);}
  public void run(){
    for(int i =1;i<=100;i++){
      System.out.println(getName()+": "+i);
      if(i%10==0){
        yield();
      }
    }
  }
}

线程优先级越高，得到的cpu执行时间片越多

线程优先级范围：1-10（默认为5）

public static final int MAX_PRIORITY：最高优先级。

public static final int NORM_PRIORITY：默认优先级

public static final int MIN_PRIORITY：最低优先级

public final int getPriority()：返回线程的优先级

public final void setPriority(int newPriority)：更改线程的优先级

public class TestPriority {
    public static void main(String[] args) {
        Thread t1 = new Thread(new T1());
        Thread t2 = new Thread(new T2());
        t1.setPriority(Thread.NORM_PRIORITY + 3);
        t1.start();
        t2.start();
    }
}

class T1 implements Runnable {
    public void run() {
        for(int i=0; i<1000; i++) {
            System.out.println("T1: " + i);
        }
    }
}

class T2 implements Runnable {
    public void run() {
        for(int i=0; i<1000; i++) {
            System.out.println("------T2: " + i);
        }
    }
}

线程总结(一),布布扣,bubuko.com

线程总结(一)

原文：http://www.cnblogs.com/shangshicc/p/3731006.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)