JAVA多线程

进程与线程

Java的第一大特色：多线程的编程支持。
多进程与多线程区别：本质区别在于，每个进程拥有自己的一整套变量，而线程则共享数据。共享变量使得线程之间的通信比进程之间通信更有效、更方便。

JAVA多线程实现

• 继承Thread类实现多线程
• Runnable()接口实现多线程
• Callable实现多线程

继承Thread类实现多线程

java.lang.Thread是一个线程操作的核心类。新建一个线程最简单的方法就是直接继承Thread类，而后覆写该类中
的run()方法(就相当于主类中的main方法)

    ++++++++++++++++++++++++++++ extends++++++++++++++++++++++++
class MyThread extends Thread{
    private String name;
    public MyThread(String name) {
    this.name = name;
}
    @Override
    public void run() {//覆写run（）方法创建线程
    System.out.println(name+" is running");
    }
}

    public class Test {
        public static void main(String[] args) throws InterruptedException, ExportException {
        //+++++++++++++++++++ extends Thread +++++++++++++++++++++
        MyThread mythread1 = new MyThread("thread1");
        MyThread mythread2 = new MyThread("thread2");
        MyThread mythread3 = new MyThread("thread3");
        Thread thread1 = new Thread(mythread1);
        Thread thread2 = new Thread(mythread2);
        Thread thread3 = new Thread(mythread3);
        thread1.start();//始终是start（）方法启动线程
        thread2.start();
        thread3.start();
        }
    }

Runnable()接口实现多线程

Thread类的核心功能是进行线程的启动。如果一个类为了实现多线程直接去继承Thread类就会有但继承局限。在
java中又提供有另外一种实现模式：Runnable接口。

class MyThread implements Runnable {
    private String name;
    public MyThread(String name) {
        this.name = name;
}
    @Override
    public void run() {
        System.out.println(name + " is running ");
    }
}
public class Test {
    public static void main(String[] args) throws InterruptedException, ExportException {
        MyThread mythread1 = new MyThread("thread1");
        MyThread mythread2 = new MyThread("thread2");
        MyThread mythread3 = new MyThread("thread3");
        Thread thread1 = new Thread(mythread1);
        Thread thread2 = new Thread(mythread2);
        Thread thread3 = new Thread(mythread3);
        thread1.start();    
        thread2.start();    
        thread3.start();    
    }
}

Thread与Runnable区别

• 首先从使用形式来讲，明显使用Runnable实现多线程要比继承Thread类要好，因为可以避免但继承局限。

• Thread类是Runnable接口的子类，那么Thread类一定覆写了Runnable接口的run()方法

  
  在多线程的处理上使用的就是代理设计模式。除了以上的关系之外，实际上在开发之中使用Runnable还有一个特
  点：使用Runnable实现的多线程的程序类可以更好的描述出程序共享的概念(并不是说Thread不能)
  Runnable实现的多线程的程序类可以更好的描述出程序共享的概念

  Callable实现多线程

  这是JDK1.5提供的一个，与Runnable（）类似，但是它的不同之处在于callable（）具有返回值

   //++++++++++++++++++++++callable<>++++++++++++++++++++++++
  class MyThread2 implements Callable<String>{
      private int ticket =10;
      @Override
      public String call() throws Exception {
      while (ticket > 0) {
      System.out.println(Thread.currentThread().getName() + " 票还剩 " + --ticket);
  }
      return "票已经卖完了";
      }
  }
  public class Test {
  public static void main(String[] args) throws InterruptedException, ExportException {
  //+++++++++++++++++Callable ++++++++++++++++++++
      FutureTask<String> myThread2 = new FutureTask<>(new MyThread2());
      new Thread(myThread2,"thread1").start();
      System.out.println(myThread2.get());
      }
  }
  

多线程的常用操作方法

线程命名与取得

起名：

MyThread mythread1 = new MyThread("thread1");

起名：

MyThread  myThread = new MyThread();
    new Thread(myThread,"thread1").start();//取名为thread1

取名：

    public String call() throws Exception {
        while (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + " 票还剩 " + --ticket);
        }

如果没有设置线程名字，则会自动分配一个线程名字。需要注意的是，线程名字如果要设置应该避免重复，同时中间不要修改。

>其他方法

线程休眠(sleep方法)

线程休眠：指的是让线程暂缓执行一下，等到了预计时间之后再恢复执行。
线程休眠会交出CPU，让CPU去执行其他的任务。但是有一点要特别注意，sleep方法不会释放锁，也就是说如果
当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象
方法：

public static native void sleep(long millis) throws InterruptedException

休眠时间使用毫秒作为单位。

        thread1.start();//如果重复启动java.lang.IllegalThreadStateException
        try {
            Thread.sleep(1000);//让线程thread1睡一秒
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

线程让步(yield()方法)

暂停当前正在执行的线程对象，并执行其他线程。也就是说调用yield方法会让当前线程交出CPU权限，让CPU去执行其他线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU时间，此外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。
还需注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。

public void run() {
    for (int i = 0; i < 3 ; i++) {
        Thread.yield();
        System.out.println("当前线程：" + Thread.currentThread().getName()+" ,i = " +i);
}
}

join()方法

等待该线程终止。意思就是如果在主线程中调用该方法时就会让主线程休眠，让调用该方法的线程run方法先执行完毕之后在开始执行主线程。

thread.join();

线程停止

多线程中有三种方式可以停止线程。

• 设置标记位，可以是线程正常退出。
• 使用stop方法强制使线程退出，但是该方法不太安全所以已经被废弃了。
• 使用Thread类中的一个interrupt() 可以中断线程。

public void run() {
    int i = 1;
    while (flag) {
        //线程操作
}
public void setFlag(boolean flag) {
    this.flag = flag;//线程结束，修改标志位
}

不建议使用，stop方法，当调用stop方法时，线程会立即停止，有可能线程正在执行某一项任务，数据还没处理完，就立即停止了，也就产生了不完整数据。

另一种就是使用interrupt()方法

interrupt() 方法只是改变中断状态而已，它不会中断一个正在运行的线程。这一方法实际完成的是，给受阻塞的线程发出一个中断信号，这样受阻线程就得以退出阻塞的状态然而interrupte()方法并不会立即执行中断操作；具体而言，这个方法只会给线程设置一个为true的中断标志（中断标志只是一个布尔类型的变量），而设置之后，则根据线程当前的状态进行不同的后续操作。如果，线程的当前状态处于非阻塞状态，那么仅仅是线程的中断标志被修改为true而已；如果线程的当前状态处于阻塞状态，那么在将中断标志设置为true后，还会有如下三种情况之一的操作：
如果是wait、sleep以及jion三个方法引起的阻塞，那么会将线程的中断标志重新设置为false，并抛出一个
InterruptedException；如果在中断时，线程正处于非阻塞状态，则将中断标志修改为true,而在此基础上，一旦进入阻塞状态，则按照阻塞状态的情况来进行处理；例如，一个线程在运行状态中，其中断标志被设置为true之后，一旦线程调用了wait、jion、sleep方法中的一种，立马抛出一个InterruptedException，且中断标志被程序会自动清除，重新设置为false。通过上面的分析，我们可以总结，调用线程类的interrupted方法，其本质只是设置该线程的中断标志，将中断标志设置为true，并根据线程状态决定是否抛出异常。因此，通过interrupted方法真正实现线程的中断原理是：开发人员根据中断标志的具体值，来决定如何退出线程。

更多JAVA相关可以参考这本书：

书中内容讲述十分仔细，比《Think In JAVA》简单得多。
>JAVA 7 程序设计入门经典（上）<
>JAVA 7 程序设计入门经典（下）<