多线程（2）

一：线程中的一些方法(线程中存在的现象)
A.线程加入
public final void join()
等待该线程中止，其他线程才能继续抢着执行 。

MyThread.java

package com.study_01;public class MyThread extends Thread {    @Override    public void run() {        for(int i=0;i<10;i++){            System.out.println(this.getName()+"--- "+i);        }    }}

Test.java

package com.study_01;/** * 线程加入        public final void join()        等待该线程中止，其他线程才能继续抢着执行 * @author dell * */public class Test {    public static void main(String[] args) {        //创建三个线程        MyThread t1 = new MyThread();        MyThread t2 = new MyThread();        MyThread t3 = new MyThread();        //给三个线程命名        t1.setName("关羽");        t2.setName("刘备");        t3.setName("曹操");        //开启线程，并且让t1先执行        t1.start();        try {            t1.join();        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }        t2.start();        t3.start();     }}

可通过运算结果的执行了解该方法的调用。
B.线程礼让
public static void yield():暂停当前正在执行的线程对象，并执行其他线程。
作用：让线程间的执行更和谐一些，但是实际上做不到。可以通过后面讲解的知识来实现。

MyThread.java

package com.study_02;public class MyThread extends Thread{    @Override    public void run() {        for(int i=0;i<10;i++){            System.out.println(this.getName()+"--"+i);            //再调用run方法的时候实现线程礼让            Thread.yield();        }    }}

Test.java

package com.study_02;/** * public static void yield():暂停当前正在执行的线程对象，并执行其他线程。         作用：让线程间的执行更和谐一些，但是实际上做不到。可以通过后面讲解的知识来实现。 * @author dell * */public class Test {    public static void main(String[] args) {        //创建三个线程        MyThread mt1 = new MyThread();        MyThread mt2 = new MyThread();        MyThread mt3 = new MyThread();        //给线程命名        mt1.setName("贾宝玉");        mt2.setName("林黛玉");        mt3.setName("薛宝钗");        //开启线程        mt1.start();        mt2.start();        mt3.start();        }}

C.线程死亡
public final void stop():直接杀死
public void interrupt():直接杀死，在死前，还可以有遗言。

Mythread.java

package com.study_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(10000);        } catch (InterruptedException e) {            System.out.println("我被杀死了");        }        System.out.println("结束时间为："+new SimpleDateFormat("HH:mm:ss").format(new Date()));    }}

Test.java

package com.study_03;/** * public final void stop():直接杀死   public void interrupt():直接杀死，在死前，还可以有遗言。 * @author dell * */public class Test {    public static void main(String[] args) {        //创建线程        MyThread t = new MyThread();        //开启线程        t.start();        try {            //在线程睡眠2s的时候将它杀死            t.sleep(2000);            //t.stop();//直接就死掉了，不给任何说话的机会            t.interrupt();//还可以继续执行程序，执行完在死        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }       }}

D.线程休眠
static void sleep(long millis) 线程睡一会
二：线程的生命周期(画图讲解)，面试题
1.新建
2.就绪
3.运行
4.有可能阻塞
5.死亡

三：线程间通信(生产消费者问题)：不同类型线程针对同一个资源的操作画图讲解：
A.系统不仅要卖票还要入票
B.不仅要卖肉夹馍还要生产肉夹馍

四：案例：以给学生设置和获取姓名和年龄为例，演示线程通信问题线程间通讯：
方法：A.私有化Student类的成员变量
B.在类的内部提供设置和获取的同步方法

资源：Student.java

package com.study_06;public class Student {    //定义学生属性    private String name;    private int age;    private boolean flag;    //将设置线程中的的功能封装为一个方法    public synchronized void setInfo(String name,int age){        while(true){            if(this.flag){                try {                    this.wait();                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }                //设置姓名和年龄                this.name="谢娜";                this.age=30;                //更改标记，唤醒获取数据开始获取                this.flag=true;                this.notify();            }        }    }    //将获取线程中的功能封装为一个方法    public synchronized void getInfo(){        while(true){            if(!this.flag){                try {                    this.wait();                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }                System.out.println(this.name+"--"+this.age);                this.flag=false;                this.notify();            }        }    }}

设置数据线程：SetThread.java

package com.study_06;public class SetThread implements Runnable {    private Student s;    private int x;    public  SetThread(Student s){        this.s=s;    }    @Override    public void run() {        synchronized (s) {            while(true){                if(x%2==0){                    s.setInfo("谢娜", 30);                    }else{                    s.setInfo("张杰", 28);                }                x++;            }           }    }}

获取数据线程：GetThread.java

package com.study_06;public class GetThread implements Runnable {    private Student s;    public  GetThread(Student s){        this.s=s;    }    @Override    public void run() {        while(true){            s.getInfo();            }        }    }

测试类：StudentTest.java

package com.study_06;public class StudentTest {    public static void main(String[] args) {        //创建学生对象        Student s = new Student();        //创建俩个线程        SetThread st1 = new SetThread(s);        GetThread gt2 = new GetThread(s);        Thread t1 = new Thread(st1);        Thread t2 = new Thread(gt2);        //开启线程        t1.start();        t2.start();    }}

五：线程组
线程组：Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
默认情况下，所有的线程都属于主线程组。
public final ThreadGroup getThreadGroup():获取线程对应的线程组对象
我们也可以给线程设置分组
Thread(ThreadGroup group, Runnable target)
案例1：创建线程获取对应的线程组对象，并获取名称
案例2：创建线程组对象，给线程分配线程组

MyRunnable.java

package com.study_07;public class MyRunnable implements Runnable{    @Override    public void run() {    }}

MyThread.java

package com.study_07;public class MyThread extends Thread{    @Override    public void run() {    }}

Test.java

package com.study_07;public class Test {    public static void main(String[] args) {        //案例1：创建线程获取对应的线程组对象，并获取名称        //创建线程对象        MyThread mt1 = new MyThread();        MyThread mt2 = new MyThread();        //获取线程组对象        ThreadGroup t1 = mt1.getThreadGroup();        ThreadGroup t2 = mt2.getThreadGroup();        //获取线程组名称        System.out.println(t1.getName());        System.out.println(t2.getName());           System.out.println("------------------------");        //案例2：创建线程组对象        ThreadGroup tg = new ThreadGroup("吴亦凡");        //分配新的线程组对象        Thread tt1 = new Thread(tg, new MyRunnable());        Thread tt2 = new Thread(tg, new MyRunnable());        //获取线程组对象        ThreadGroup tg1 = tt1.getThreadGroup();        ThreadGroup tg2 = tt2.getThreadGroup();        //获取线程组名称        System.out.println(tg1.getName());        System.out.println(tg2.getName());    }}

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

package com.study_10;import java.util.concurrent.Callable;public class MyCallable implements Callable<Integer>{//这里的泛型就是返回值的类型    private int start;    private int end;    public MyCallable(int start,int end){        this.start=start;        this.end=end;       }    @Override    public Integer call() throws Exception {        int sum=0;        for(int i=0;i<end+1;i++){            sum+=i;        }        return sum;    }}

Test.java

package com.study_10;//案例3：实现Callable接口实现线程池的使用，实现多线程求和，1-10之和，1-100之和import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;public class Test {    public static void main(String[] args) throws Exception {        //创建线程池        ExecutorService pool = Executors.newFixedThreadPool(2);        //创建任务        MyCallable mc1 = new MyCallable(1, 10);        MyCallable mc2 = new MyCallable(1, 100);        //提交任务        Future<Integer> s1 = pool.submit(mc1);        Future<Integer> s2 = pool.submit(mc2);        //输出结果        System.out.println(s1.get());        System.out.println(s2.get());        //关闭线程池        pool.shutdown();    }}

七：定时器
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.study_12;import java.io.File;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Timer;import java.util.TimerTask; /**         * 案例2：定时删除文件(需要在19：08：00 删除D：//a.txt文件)         * 所用方法：schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务         * 时间点：19:08:00         * 任务：删除D：//a.txt文件         */public class TimerTest {    public static void main(String[] args) throws Exception {        //创建一个定时器        Timer t = new Timer();        String time="2017-5-23 19:08:00";        Date date = new SimpleDateFormat("yyyy-MM-dd hh:MM:ss").parse(time);        t.schedule(new MyTaskTest(), date);    }}class MyTaskTest extends TimerTask {    @Override    public void run() {        File file = new File("d:\\a.txt");        file.delete();    }}