java线程

1.什么是线程

一个程序可以同时执行多个任务，每一个任务就称之为一个线程。

2.线程与进程

二者都是CPU时间段的一个描述，即某个线程或进程获得了CPU时间，进而执行其相应的任务。
线程存在于进程之中，一个进程至少包含一个线程。
每个进程都拥有自己的一整套变量，进程之间不共享，但线程则不是，它们会共享资源。

3.java中线程的创建与 启动

3.1 创建线程：
方式一：继承Thread类，但是不推荐使用这种方法定义线程，因为这使得线程任务和线程控制揉合在了一起。

//1.继承Thread类
//2.重写run方法，在run方法中定义线程所执行的逻辑，即如何去完成这个线程任务的逻辑。
public class MyThread extends Thread{
    //构造方法，可以设置一些参数
    public MyThread(){
    }
    //重写run方法
    @Override
    public void run() {
        //线程要执行的逻辑：每隔一秒输入当前时间
        while(true) {
            try {
                System.out.println(new Date());
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } 

        }
    }

}

方式二：实现Runnable接口

//1.实现Runnable接口
//2.重写run方法，在run方法中实现业务逻辑
public class MyThread implements Runnable{
    //构造方法，可以设置一些参数
    public MyThread() {
    }
    @Override
    public void run() {
        while(true) {
            try {
                System.out.println(new Date());
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

3.2 启动线程

//对继承Thread类定义的线程，直接调用该对象的start()。
public static void main(String[] args) {
    MyThread t = new MyThread();//MyThread类继承自Thread类
    t.start();
}


//对于实现Runnable接口而定义的线程类，则要将该线程对象作为参数传给Thread类对象，然后调用Thread类的start()方法。
public static void main(String[] args) {
    MyRunnable r = new MyRunnable();//实现了Runnable接口
    Thread t = new Thread(r);
    t.start();
}

3.3 为什么启动线程要调用start()方法而不调用run()方法？看下面的例子。

public static void main(String[] args) {
    MyRunnable r = new MyRunnable();//实现了Runnable接口，此类为上面的MyRunnable类。//1
    Thread t = new Thread(r);//2
    t.start();//3
    System.out.println("线程执行了吗？");//4
}
//此时运行上面的代码，执行了语句3后程序不会阻塞，接着语句4会立马执行。
/*如果将语句3改为 t.run();则程序也会执行run方法中定义的循环，由于上面run方法中定义的是一个无限循环，
而语句4必须要等等语句3执行完成后方能执行，故此时语句4是永远不会被执行的。此时你可以将run方法中的循环定义
为一个有限循环，你会发现循环执行完了才会输出语句4.
由此可见，如果调用run方法，它只是被当作一个普通方法。
*/

3.4 练习：写一个程序，同时执行三个线程任务：输出字母a 100次，输出字母b 100次，输出1~100之间的整数。

4.线程的状态

4.1 线程的几种状态

• 新建状态：当我们new了一个Thread对象时，此时线程就处于新建状态。
• 可运行状态：当调用了start方法后，线程可能会马上执行，也可能不会。此时叫可运行状态。
• 运行状态：当线程抢到了CPU资源，此时线程就会执行，因此处于运行状态。
• 阻塞状态：将调用sleep，wait等方法后，线程仍是活的，但是它不具有可执行条件，而是需要等待某一事件的触发（如睡眠时间到了，notify方法等），才会回到可运行状态。
• 死亡状态：线程执行完了，就会进入死亡状态。

4.2 线程Thread类的相关方法

• start：使线程开始执行，java虚拟机调用run方法，此时会有2个线程并发执行，当前线程（调用start方法并返回）和另一个线程（执行run方法），重复启动同一个线程会报错。

• sleep：
  static void sleep（long millis）让线程暂停指定毫秒数。
  static void sleep(long millis, int nanos)让线程暂停指定的毫秒数加纳秒数。nanos值 为0~999999。
  该方法线程不会释放它所持有的锁。
  sleep方法可以会抛出InterruptedException , 这是一个必检异常。所以要将其放在try-catch块中执行，注意，当在一个循环中调用sleep方法时，要将整个循环放入try-catch块中，而不能将try-catch块放在循环中（这样的话线程发生异常后也还会继续执行）。

      try {
              while(.....) ｛
                  Thread.sleep(1000);
              ｝
          } catch (InterruptedException e) {  //当前线程被其它线程中断时发生
              e.printStackTrace();
          }

• yeild：
  static void yeild()
  暂停执行当前线程，但此时它不是处于阻塞状态，而是处于可执行状态，它仍会参与争夺CPU时间。

• activeCount :
  static int activeCount()
  返回当前线程组中活的线程数量。Thread.activeCount();

• currentThread
  static Thread currentThread()
  返回当前执行的线程。Thread.currentThread();

• getState
  Thread.state getState() 返回线程状态，只用于监视系统状态。
  NEW:创建后从未启动的线程。
  RUNNABLE:可运行行的线程。
  BLOCKED:受阻塞并等待某个监视器锁的线程。
  WAITING:无限期等待另一个线程来执行某一特定操作的线程。
  TIME WAITING:计时等待的线程。
  TERMINATED:已退出的线程。

• interrupt
  void interrupt()
  向线程发送中断请求，此时线程的中断状态会被改为true.如果此时线程被一个sleep方法阻塞，会抛出InterruptException异常。
• interrupted
  static boolean interrupted()
  检查当前线程是否已经中断，它会将当前线程的中断状态由true重置为false。
• isInterrupted
  检查当前线程是否已经中断，它不会像上面方法那样重置线程的中断状态。

public class MyRunnable1 implements Runnable{

    private String name;
    private int num;
    public MyRunnable1(String name,int num) {
        this.name = name;
        this.num = num;
    }
    public void run() {
        while(num < 100) {
            System.out.println(name + ":" + num);
            num++;
            if(num == 80) {
                Thread.currentThread().interrupt();
                System.out.println(num + ":"+Thread.currentThread().isInterrupted());//ture
            }
            if(Thread.interrupted()) {//当num=80时其本身会返回true，但它会将当前线程中断状态改为false。
                System.out.println(num + ":"+Thread.currentThread().isInterrupted());//false
            }
            System.out.println(Thread.currentThread().isInterrupted());
        }
    }
}

• join
  void join() 主线程等待该线程（调用join方法的线程）执行完了再继执行。
  void join(long millis) 当millis为0，则意味着一直等下去，直到线程执行完成。
  void join(long millis，int nanus) nanus的值为0~999999

//线程类
public class MyRunnable implements Runnable{
    private int i;  
    public MyRunnable(int i) {
        this.i = i;
    }
    @Override
    public void run() {
        while(i < 10) {
            System.out.println(i);
            i++;
            try {
                Thread.sleep(100);//睡眠100毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }       
    }
}

//在一个测试类的main方法中调用这个线程
public class ThreadTest {

    public static void main(String[] args) {
        MyRunnable r = new MyRunnable(0);
        Thread t = new Thread(r);
        t.start();
        try {
            t.join();//语句1
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程执行完了");//语句2
    }
}
/*
此时运行的结果是先输出线程中的循环，最后输出语句2，如果将语句1（try-catch块）注释掉，此时的执行结果先输出语句2，再输入线程中的循环。这说明当线程t调用了join方法后，main主线程会等待线程t执行完了再继续往下执行。你还可以在join方法中传入时间参数，如500，观察运行结果的变化。
*/

• isDaemon
  final boolean isDaemon() 判断该线程是否是一个守护线程。
• setDaemon
  final void setDaemon(boolean on)标记该线程为守护线程（true）或用户线程（false）.当正在运行的线程都是守护线程时，JVM退出。守护线程是为其他线程提供服务的，所以可能会在任何时候中断（因为只要其他线程都执行完成了，就只会剩下守护线程在执行，此时JVM就会自动退出），因此守护线程永远不要去访问资源（文件，数据库）。另外这一方法必须在启动线程之前调用。GC就是一个经典的守护线程。

//守护线程，这是一个无限循环
public class DaemonThread implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println(new Date());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

}


//用户线程，输入10次
public class UserThread implements Runnable {
    @Override
    public void run() {
        int i = 0;
        while (i < 10) {
            System.out.println("User Thread:" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            i++;
        }
    }
}

//测试
public class ThreadTest {
    public static void main(String[] args) {
        DaemonThread daemon = new DaemonThread();//守护线程
        UserThread user = new UserThread();//用户线程
        Thread d = new Thread(daemon);
        d.setDaemon(true);//设为守护线程，语句1
        Thread u = new Thread(user);
        d.start();
        u.start();
    }
}
//运行会发现用用户线程执行完成后，程序就退出执行了。如果此时将语句1的参数改为false，则会一直进行下去。

• setName
  void setName(String name) 设置线程名称
• setPriority
  void setPriority(int newPriority) 设置优先级，线程默认会继承生成它的线程的优先级。
• -