java-多线程（二）

引言
下面对有关多线程的介绍做了更深一步的了解。
线程中的一些方法
线程加入
public final void join()
等待该线程中止，其他线程才能继续抢着执行
线程礼让
public static void yield():暂停当前正在执行的线程对象，并执行其他线程。
作用：让线程间的执行更和谐一些，但是实际上做不到。可以通过后面讲解的知识来实现。
线程死亡
public final void stop():直接杀死
public void interrupt():直接杀死，在死前，还可以有遗言。
线程休眠
static void sleep(long millis) 线程睡一会
在上述四种方法中，简单用代码介绍其中一种方法，线程死亡

package com.stu_03;import java.text.SimpleDateFormat;import java.util.Date;public class MyThread extends Thread{      @Override    public void run() {        System.out.println("开始时间："+new SimpleDateFormat("HH:mm:ss").format(new Date()));          try {            Thread.sleep(1000);        } catch (InterruptedException e) {            // TODO Auto-generated catch block            //e.printStackTrace();            System.out.println("我被杀死了");        }          System.out.println("结束时间："+new SimpleDateFormat("HH:mm:ss").format(new Date()));      } }//测试package com.stu_03;/* * 线程死亡   public final void stop():直接杀死   public void interrupt():直接杀死，在死前，还可以有遗言。 */public class Test {    public static void main(String[] args) {        //创建线程        MyThread mt = new MyThread();        //开启线程        mt.start();        //直接杀死线程//      mt.stop();        //在睡眠过程中杀死线程        try {            Thread.sleep(1000);//          mt.stop();            //有遗言的杀死            mt.interrupt();        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }           }}

编译运行interrupt（）部分的结果：
开始时间：14:34:44
我被杀死了
结束时间：14:34:45
线程的生命周期（重点）
用一张图对线程的生命周期做一个详细的介绍

线程间通信(生产消费者问题)：不同类型线程针对同一个资源的操作
用一个简单的学生案例来理解：
线程间通讯：
资源：Student
设置数据线程：SetThread
获取数据线程：GetThread
测试类：StudentTeat
相关代码如下：

//学生javabeanpackage com.stu_04;public class Student {    private String name;    private int age;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public Student(String name, int age) {        super();        this.name = name;        this.age = age;    }    public Student() {        super();        // TODO Auto-generated constructor stub    }}//setThreadpackage com.stu_04;public class SetThread implements Runnable{      private Student s;    private int x=0;    public SetThread(Student s) {        this.s = s;    }    @Override    public void run() {        while (true) {            synchronized (s) {                if (x%2==0) {                    s.setName("薛之谦");                    s.setAge(35);                }else{                    s.setName("黄晓明");                    s.setAge(36);                }                x++;            }               }    }}//GetThreadpackage com.stu_04;public class GetThread implements Runnable{    private Student s;    public GetThread(Student s) {        this.s = s;    }    @Override    public void run() {        while (true) {            synchronized (s) {                System.out.println(s.getName()+"--"+s.getAge());            }        }       }}//StudentTestpackage com.stu_04;public class StudentTest {    public static void main(String[] args) {        //创建学生对象        Student s = new Student();        //创建设置线程和得到线程        GetThread gt = new GetThread(s);        SetThread st = new SetThread(s);        //创建线程        Thread t1 = new Thread(st);        Thread t2 = new Thread(gt);        //开启线程        t1.start();        t2.start();    }}

编译运行结果如下（部分）
薛之谦–35
薛之谦–35
薛之谦–35
黄晓明–36
黄晓明–36
黄晓明–36
黄晓明–36
线程组
线程组：Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
默认情况下，所有的线程都属于主线程组。
public final ThreadGroup getThreadGroup():获取线程对应的线程组对象
我们也可以给线程设置分组
Thread(ThreadGroup group, Runnable target)
同样的，用两个简单的案例解释：
案例1：创建线程获取对应的线程组对象，并获取名称
案例2：创建线程组对象，给线程分配线程组

// 案例1：创建线程获取对应的线程组对象，并获取名称package com.stu_07;public class MyThread extends Thread{    @Override    public void run() {        // TODO Auto-generated method stub        super.run();    }}//  案例2：创建线程组对象，给线程分配线程组package com.stu_07;public class MyRunnable implements Runnable{    @Override    public void run() {        // TODO Auto-generated method stub      }}//测试package com.stu_07;public class Test {    public static void main(String[] args) {//      //创建两个线程//      MyThread mt1 = new MyThread();//      MyThread mt2 = new MyThread();//      //案例1：创建线程获取对应的线程组对象，并获取名称//      //获取对应得线程组对象//      ThreadGroup tg1 = mt1.getThreadGroup();//      ThreadGroup tg2 = mt2.getThreadGroup();//      //获取名称//      System.out.println(tg1.getName());//main//      System.out.println(tg2.getName());//main        // 案例2：创建线程组对象，给线程分配线程组        ThreadGroup tg = new ThreadGroup("薛之谦");        Thread mt3 = new Thread(tg, new MyRunnable());        Thread mt4 = new Thread(tg, new MyRunnable());          //获取对应的线程组对象        ThreadGroup tg3 = mt3.getThreadGroup();        ThreadGroup tg4 = mt4.getThreadGroup();        //获取名称        System.out.println(tg3.getName());        System.out.println(tg4.getName()    );    }}

其中，案例一的运行结果在代码中有相应显示，案例二的编译运行结果如下：
薛之谦
薛之谦
线程池
为什么要使用线程池？
程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。
线程池的特点：
线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。
在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池。
线程池如何创建？
JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
public static ExecutorService newFixedThreadPool(int nThreads)
线程池的使用步骤：
1.创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2);
参数：nThreads - 池中的线程数
2.创建Runnable实例
MyRunnable my = new MyRunnable();
3.提交Runnable实例
pool.submit(my);
pool.submit(my);
4.关闭线程池
pool.shutdown();
案例：实现Callable接口实现线程池的使用，实现多线程求和，1-10之和，1-100之和

package com.stu_10;import java.util.concurrent.Callable;public class MyCallable implements Callable<Integer>{    private int start;    private int end;    public MyCallable(int start, int end) {        super();        this.start = start;        this.end = end;    }    @Override    public Integer call() throws Exception {        int sum=0;        for (int i = start; i < end+1; i++) {            sum+=i;        }        return sum;    }}//测试package com.stu_10;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;//实现Callable接口实现线程池的使用，实现多线程求和，1-10之和，1-100之和public class Test {    public static void main(String[] args) throws Exception {        //创建线程池对象        ExecutorService pool = Executors.newFixedThreadPool(2);        //创建Callable实例        MyCallable mc1 = new MyCallable(1, 10);        MyCallable mc2 = new MyCallable(1, 100);        //提交Callable实例        Future<Integer> s1 = pool.submit(mc1);        Future<Integer> s2 = pool.submit(mc2);        System.out.println(s1.get());        System.out.println(s2.get());        //关闭线程池        pool.shutdown();    }}

运行结果：
55
5050
定时器
Timer
public Timer()构造
public void schedule(TimerTask task, long delay)延迟多久执行任务
public void schedule(TimerTask task,long delay,long period)延迟多久执行任务，并以后每隔多久执行一次
public boolean cancel()取消这个任务
TimerTask
public abstract void run()放的是所要执行的任务代码
需求：定时删除文件
所用方法：schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务

package com.stu_11;import java.io.File;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Timer;import java.util.TimerTask;//定时删除文件public class TimerTest03 {    public static void main(String[] args) throws Exception {        //schedule(TimerTask task, Date time)         //安排在指定的时间执行指定的任务        Timer t = new Timer();        String time="2017-5-23 17:41:00";        Date date=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(time);        t.schedule(new MyTimerTask2(), date);       }}class MyTimerTask2 extends TimerTask {    @Override    public void run() {        File file = new File("a.txt");        file.delete();    }}