首页 > 代码库 > 线程总结(一)

线程总结(一)

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

一般操作系统支持多线程,多进程。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);
        }
    }
}