Java 线程 笔记（1）

线程是一个程序内部的顺序控制流

线程和进程的区别：

    1.  每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销

    2.  线程可以看成是轻量级的进程，同一类的线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器

         线程切换开销小

    3.  多进程：在操作系统中可以运行多个任务

         多线程：在同一应用程序中，有多个顺序流同时执行

 

Java的线程是通过java.lang.Thread类来实现的

VM启动时，会有一个由主方法（public static void main(String[ ] args)）定义的线程

通过创建Thread类的新实例来创建新的线程

每个线程都是通过特定Thread对象所对应的run( )方法来执行操作，方法run( )称为线程体

通过调用Thread类的start( )方法来启动线程

 

 

两种创建新线程的方式：

1.定义线程类实现接口Runnable

Runnable 里只有一个run( )方法， 没有其他的内容。

public void run( );   用来定义线程运行体

使用Runnable接口，可以为多个线程提供共享的数据  （这些共享数据的线程需要时同一类）

构造方法：

Thread(Runnable target)  实际使用的时候，传入的是实现了这个接口的对象，父类引用指向子类对象。

 

   1:  public class TestThread1 {

   2:      public static void main(String args[]) {

   3:      Runner1 r = new Runner1();      //new了一个线程类的对象

   4:          //要想起一个线程，要new一个Thread对象

5: t.start(); //线程启动，告诉CPU，现在有个新的线程。

这个必须调用Thread实例的start()方法

   6:      for(int i=0; i<100; i++) {      //产生了一个新的分支，两个线程交替执行 

   7:      System.out.println("Main Thread:------" + i);

   8:          }

   9:      }

  10:  }

  11:   

  12:   {

  13:                  public void run() {

  14:      for(int i=0; i<100; i++) {    

  15:      System.out.println("Runner1 :" + i);

  16:          }

  17:      }

  18:  }

  执行结果就是 两个线程交替执行，交替输出0-100的数

 

public class TestThread1 {
    public static void main(String args[]) {
    Runner1 r = new Runner1();
   ;           // 调用Runner1对象的run()方法，执行完以后，才继续向下执行，
                                 没有多线程
    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);
        }
    }

执行结果就是 先run()方法，再main()里的println()方法

 

2.定义一个Thread类的子类，并重写run方法

   class MyThread extends Thread{

      public void run(){

      }                

}

然后生成该类的对象

MyThread mythread = new MyThread(…);

 

public class TestThread1 {
    public static void main(String args[]) {
        Runner1 r = new Runner1();        //Runner1是Thread的子类
        r.start();                //调用Thread子类对象的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);
        }
    }
}

结果是2个线程交替执行。

 

tips：能使用接口的时候，不要从Thread类继承

 

线程控制基本方法：

isAlive() ——————判断线程是否还活着，是否还未终止

getPriority()—————获得线程的优先级数值

setPriority()——————设置线程的优先级数值

Thread.sleep()—————将当前线程睡眠指定毫秒数

join()————————调用某线程的该方法，将当前线程与该线程合并，等待该线程结束，再恢复当前线程的运行

yield()————————让出CPU

sleep方法：

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

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