木叶隐秘传体术奥义·千年杀
日本漫画《火影忍者》中的一种体术
木叶隐秘传体术奥义·千年杀，日本漫画《火影忍者》及其衍生作品中，由“木叶白牙”旗木朔茂所开发的E级体术（在小李忍传中得知），为了能够将此术流传到后世，木叶白牙将此术传授给了他的儿子卡卡西。
据汤隐忍者所述，正因为千年杀的恐怖杀伤力，旗木朔茂才被人称作木叶的白色獠牙。据卡卡西所说，卡卡西的千年杀威力远不及朔茂。

使用原理
此术是由“木叶白牙”旗木朔茂所开发的E级体术（在小李忍传中得知），为了能够将此术流传到后世，木叶白牙将此术传授给了他的儿子卡卡西。
据汤隐忍者所述，正因为千年杀的恐怖杀伤力，旗木朔茂才被人称作木叶的白色獠牙。据卡卡西所说，卡卡西的千年杀威力远不及朔茂。

Java篇线程的使用-------------线程的终止，休眠，让步及联合

终止线程

线程我们一般不使用JDK提供的stop()/destroy()方法(它们本身也被JDK废弃了)。通常的做法是提供一个boolean型的终止变量，当这个变量置为false，则终止线程的运行。

终止线程的典型方法

public class StopThread implements Runnable {
  private boolean flag = true;
  @Override
  public void run() {
    System.out.println(Thread.currentThread().getName()+" 线程开始");
      int i= 0;
      while(flag){
        System.out.println(Thread.currentThread().getName()+" "+i++);
        try {
          Thread.sleep(1000);
         } catch (InterruptedException e) {
                 e.printStackTrace();
         }
       }
    System.out.println(Thread.currentThread().getName()+" 线程结束");
   }
  public void stop(){
    this.flag = false;
   }

  public static void main(String[] args)throws Exception {
    System.out.println("主线程开始");
    StopThread st = new StopThread();
   Thread t1 = new Thread(st);
    t1.start();
    System.in.read();
    st.stop();
    System.out.println("主线程结束");
   }
}

线程休眠

ep()方法：可以让正在运行的线程进入阻塞状态，直到休眠时间满了，进入就绪状态。sleep方法的参数为休眠的毫秒数。

public class SleepThread implements Runnable {
  @Override
  public void run() {
    System.out.println(Thread.currentThread().getName()+" 线程开始");
     for(int i=0;i<20;i++){
       System.out.println(Thread.currentThread().getName()+" "+i);
        try {
          //线程休眠1秒
         Thread.sleep(1000);
         } catch (InterruptedException e) {
          e.printStackTrace();
         }
       }
    System.out.println(Thread.currentThread().getName()+" 线程结束");
  }

  public static void main(String[] args) {
    System.out.println("主线程开始");
    Thread t = new Thread(new SleepThread());
    t.start();
    System.out.println("主线程结束");
   }
}

线程让步

yield()让当前正在运行的线程回到就绪状态，以允许具有相同优先级的其他线程获得运行的机会。因此，使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。但是，实际中无法保证yield()达到让步的目的，因为，让步的线程可能被线程调度程序再次选中。

使用yield方法时要注意的几点：

yield是一个静态的方法。
调用yield后，yield告诉当前线程把运行机会交给具有相同优先级的线程。
yield不能保证，当前线程迅速从运行状态切换到就绪状态。
yield只能是将当前线程从运行状态转换到就绪状态，而不能是等待或者阻塞状态。

public class TestyieldThread implements Runnable {
  @Override
  public void run() {
    for(int i=0;i<30;i++){
      if("Thread-0".equals(Thread.currentThread().getName())){
        if(i == 0){
          Thread.yield();
         }
       }
      System.out.println(Thread.currentThread().getName()+" "+i);
     }
   }

  public static void main(String[] args) {
    Thread t1 = new Thread(new TestyieldThread());
    Thread t2 = new Thread(new TestyieldThread());
    t1.start();
    t2.start();
   }
}

线程联合

当前线程邀请调用方法的线程优先执行，在调用方法的线程执行结束之前，当前线程不能再次执行。线程A在运行期间，可以调用线程B的join()方法，让线程B和线程A联合。这样，线程A就必须等待线程B执行完毕后，才能继续执行。

join方法的使用

join()方法就是指调用该方法的线程在执行完run()方法后，再执行join方法后面的代码，即将两个线程合并，用于实现同步控制。

class A implements Runnable{
  private Thread b;
  public A(Thread b){
    this.b = b;
   }

  @Override
  public void run() {
    for(int i=0;i<10;i++){
      System.out.println(Thread.currentThread().getName()+"  A  "+i);
      if(i == 5){
       try {
          this.b.join();
         } catch (InterruptedException e) {
          e.printStackTrace();
        }
       }
     try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
       }
     }
   }
}

class B implements Runnable{
  @Override
  public void run() {
    for(int i=0;i<20;i++){
      System.out.println(Thread.currentThread().getName()+" B "+i);
      try {
        Thread.sleep(1000);
       } catch (InterruptedException e) {
        e.printStackTrace();
       }
     }
   }
}

public class TestJoinThread {
  public static void main(String[] args) {
    Thread t1 = new Thread(new B());
    Thread t = new Thread(new A(t1));

    t.start();
    t1.start();
    for(int i=0;i<10;i++){
      System.out.println(Thread.currentThread().getName()+" "+i);
      if(i ==2){
        try {
          t.join();
         } catch (InterruptedException e) {
          e.printStackTrace();
         }
       }
      try {
        Thread.sleep(1000);
       } catch (InterruptedException e) {
        e.printStackTrace();
       }
     }
   }
}