java必学必会之线程（1）

package cn.galc.test;

public class TestThread1{
 public static void main(String args[]){
 Runner1 r1 = new Runner1();//这里new了一个线程类的对象出来
 //r1.run();//这个称为方法调用，方法调用的执行是等run()方法执行完之后才会继续执行main()方法
 Thread t = new Thread(r1);//要启动一个新的线程就必须new一个Thread对象出来
 //这里使用的是Thread(Runnable target) 这构造方法
 t.start();//启动新开辟的线程，新线程执行的是run()方法，新线程与主线程会一起并行执行
 for(int i=0;i<10;i++){
  System.out.println("maintheod："+i);
 }
 }
}
/*定义一个类用来实现Runnable接口，实现Runnable接口就表示这个类是一个线程类*/
class Runner1 implements Runnable{
 public void run(){
 for(int i=0;i<10;i++){
  System.out.println("Runner1："+i);
 }
 }
}

package cn.galc.test;

/*线程创建与启动的第二种方法：定义Thread的子类并实现run()方法*/
public class TestThread2{
 public static void main(String args[]){
 Runner2 r2 = new Runner2();
 r2.start();//调用start()方法启动新开辟的线程
 for(int i=0;i<=10;i++){
  System.out.println("mainMethod："+i);
 }
 }
}
/*Runner2类从Thread类继承
通过实例化Runner2类的一个对象就可以开辟一个新的线程
调用从Thread类继承来的start()方法就可以启动新开辟的线程*/
class Runner2 extends Thread{
 public void run(){//重写run()方法的实现
 for(int i=0;i<=10;i++){
  System.out.println("Runner2："+i);
 }
 }
}

package cn.galc.test;

import java.util.*;

public class TestThread3 {
 public static void main(String args[]){
 MyThread thread = new MyThread();
 thread.start();//调用start()方法启动新开辟的线程
 try {
  /*Thread.sleep(10000);
  sleep()方法是在Thread类里面声明的一个静态方法，因此可以使用Thread.sleep()的格式进行调用
  */
  /*MyThread.sleep(10000);
  MyThread类继承了Thread类，自然也继承了sleep()方法，所以也可以使用MyThread.sleep()的格式进行调用
  */
  /*静态方法的调用可以直接使用“类名.静态方法名”
  或者“对象的引用.静态方法名”的方式来调用*/
  MyThread.sleep(10000);
  System.out.println("主线程睡眠了10秒种后再次启动了");
  //在main()方法里面调用另外一个类的静态方法时，需要使用“静态方法所在的类.静态方法名”这种方式来调用
  /*
  所以这里是让主线程睡眠10秒种
  在哪个线程里面调用了sleep()方法就让哪个线程睡眠，所以现在是主线程睡眠了。
  */
 } catch (InterruptedException e) {
  e.printStackTrace();
 }
 //thread.interrupt();//使用interrupt()方法去结束掉一个线程的执行并不是一个很好的做法
 thread.flag=false;//改变循环条件，结束死循环
 /**
  * 当发生InterruptedException时，直接把循环的条件设置为false即可退出死循环，
  * 继而结束掉子线程的执行，这是一种比较好的结束子线程的做法
  */
 /**
  * 调用interrupt()方法把正在运行的线程打断
 相当于是主线程一盆凉水泼上去把正在执行分线程打断了
 分线程被打断之后就会抛InterruptedException异常，这样就会执行return语句返回，结束掉线程的执行
 所以这里的分线程在执行完10秒钟之后就结束掉了线程的执行
  */
 }
}

class MyThread extends Thread {
 boolean flag = true;// 定义一个标记，用来控制循环的条件

 public void run() {
 /*
  * 注意：这里不能在run()方法的后面直接写throw Exception来抛异常， 
  * 因为现在是要重写从Thread类继承而来的run()方法,重写方法不能抛出比被重写的方法的不同的异常。
  * 所以这里只能写try……catch()来捕获异常
  */
 while (flag) {
  System.out.println("==========" + new Date().toLocaleString() + "===========");
  try {
  /*
   * 静态方法的调用格式一般为“类名.方法名”的格式去调用 在本类中声明的静态方法时调用时直接写静态方法名即可。 当然使用“类名.方法名”的格式去调用也是没有错的
   */
  // MyThread.sleep(1000);//使用“类名.方法名”的格式去调用属于本类的静态方法
  sleep(1000);//睡眠的时如果被打断就会抛出InterruptedException异常
  // 这里是让这个新开辟的线程每隔一秒睡眠一次，然后睡眠一秒钟后再次启动该线程
  // 这里在一个死循环里面每隔一秒启动一次线程，每个一秒打印出当前的系统时间
  } catch (InterruptedException e) {
  /*
   * 睡眠的时一盘冷水泼过来就有可能会打断睡眠 
   * 因此让正在运行线程被一些意外的原因中断的时候有可能会抛被打扰中断(InterruptedException)的异常
   */
  return;
  // 线程被中断后就返回，相当于是结束线程
  }
 }
 }
}

package cn.galc.test;

public class TestThread4 {
 public static void main(String args[]) {
 MyThread2 thread2 = new MyThread2("mythread");
 // 在创建一个新的线程对象的同时给这个线程对象命名为mythread
 thread2.start();// 启动线程
 try {
  thread2.join();// 调用join()方法合并线程，将子线程mythread合并到主线程里面
  // 合并线程后，程序的执行的过程就相当于是方法的调用的执行过程
 } catch (InterruptedException e) {
  e.printStackTrace();
 }
 for (int i = 0; i <= 5; i++) {
  System.out.println("I am main Thread");
 }
 }
}

class MyThread2 extends Thread {
 MyThread2(String s) {
 super(s);
 /*
  * 使用super关键字调用父类的构造方法 
  * 父类Thread的其中一个构造方法：“public Thread(String name)” 
  * 通过这样的构造方法可以给新开辟的线程命名，便于管理线程
  */
 }

 public void run() {
 for (int i = 1; i <= 5; i++) {
  System.out.println("I am a\t" + getName());
  // 使用父类Thread里面定义的
  //public final String getName()，Returns this thread's name.
  try {
  sleep(1000);// 让子线程每执行一次就睡眠1秒钟
  } catch (InterruptedException e) {
  return;
  }
 }
 }
}

package cn.galc.test;

public class TestThread5 {
 public static void main(String args[]) {
 MyThread3 t1 = new MyThread3("t1");
 /* 同时开辟了两条子线程t1和t2，t1和t2执行的都是run()方法 */
 /* 这个程序的执行过程中总共有3个线程在并行执行，分别为子线程t1和t2以及主线程 */
 MyThread3 t2 = new MyThread3("t2");
 t1.start();// 启动子线程t1
 t2.start();// 启动子线程t2
 for (int i = 0; i <= 5; i++) {
  System.out.println("I am main Thread");
 }
 }
}

class MyThread3 extends Thread {
 MyThread3(String s) {
 super(s);
 }

 public void run() {
 for (int i = 1; i <= 5; i++) {
  System.out.println(getName() + "：" + i);
  if (i % 2 == 0) {
  yield();// 当执行到i能被2整除时当前执行的线程就让出来让另一个在执行run()方法的线程来优先执行
  /*
   * 在程序的运行的过程中可以看到，
   * 线程t1执行到(i%2==0)次时就会让出线程让t2线程来优先执行 
   * 而线程t2执行到(i%2==0)次时也会让出线程给t1线程优先执行
   */
  }
 }
 }
}