Java学习：多线程（2）

 线程中的一些方法

线程加入：public final void join()

　　等待该线程终止，其他线程才能抢着执行。

练习代码如下：　　　

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();
        
        //接着让mt1这个线程设置为加入线程，其他线程就没有抢占cpu执行权的权利了，只能等待该线程执行完毕之后，才能开始抢占
        try {
            mt1.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
        mt2.start();
        mt3.start();
        
    }

线程礼让：public final void yield()

　　暂停当时正在执行的县城对象，并执行其他线程。

作用：让线程间的执行更和谐，但实际上做不到。

练习代码下：

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"---"+i);
            //实现线程礼让
            Thread.yield();
        }
    }

}

线程死亡：

public final void stop():直接杀死。

练习代码如下：

MyThread mt = new MyThread();
        
        //开启线程对象
        mt.start();
        
        //在线程处于睡眠的过程中将他杀死
        
        try {
            Thread.sleep(3000);
            //杀死刚刚开启的线程
            //调用stop()方法将线程直接杀死
            mt.stop();//划了一条横线表示该方法已经过时，但是还可以使用
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

结果如下：

public void interrupt()：直接杀死，在死前还有遗言。

练习代码：

public void run() {
        //打印一下开始执行的时间
        System.out.println("开始时间："+new SimpleDateFormat("HH:mm:ss").format(new Date()));
        //休眠10秒钟
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            //e.printStackTrace();
            System.out.println("我被杀死了");
        }
        System.out.println("结束时间："+new SimpleDateFormat("HH:mm:ss").format(new Date()));
    }

MyThread mt = new MyThread();
        
        //开启线程对象
        mt.start();
        
        //在线程处于睡眠的过程中将他杀死
        
        try {
            Thread.sleep(3000);
            //杀死刚刚开启的线程
            //interrupt():直接杀死，在死前，还可以有遗言。
            mt.interrupt();//线程被杀死之后会将后面的代码执行完毕之后，再死去
            
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

线程休眠：

static void sleep(lang millis):

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

线程间通信（生产消费者问题）：不同类型线程针对同一个资源操作。我们常见一个Student对象，然后再创建一个设置Student对象的线程和一个获取Student对象的线程。

public class Student {
    String name;
    int age;
}

public class SetThread implements Runnable{
    
    private Student s;
    private int x=0;
    
    public SetThread(Student s){
        this.s = s;
    }
    
    @Override
    public void run() {
        //给学生对象设置姓名和年龄
        //Student s = new Student();
        while (true) {
            synchronized (s) {
                if (x%2==0) {
                    s.name = "大明";
                    s.age = 14;
                }else {
                    s.name = "陈小宝";
                    s.age = 12;
                }
                x++;
            }
            
        }
        
    }

}

public class GetThread implements Runnable{
    private Student s;
    
    public GetThread(Student s){
        this.s = s;
    }
    @Override
    public void run() {
        //获取线程，获取学生对象的姓名和年龄
        //Student s = new Student();
        while (true) {
            synchronized (s) {    
                System.out.println(s.name+"--"+s.age);    
            }
        }
    }

}

public class StudentDemo {
    public static void main(String[] args) {
        //创建一个学生对象
        Student s = new Student();
        
        //创建设置和获取线程，并开启线程
        SetThread st = new SetThread(s);
        GetThread gt = new GetThread(s);
        
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);
        
        //开启线程
        t1.start();
        t2.start();
        
    }

}

当我们运行这些代码时我们会发现一些问题，就是陈小宝和大明并不是交替出现的而是一个人出现好多次才出现另一个人。这是因为CPU的运行速的很快，而两个线程的抢占是随机的。

用wait方法和notify方法改进上述案例。

public class Student {
    String name;
    int age;
    boolean flag;//在这里可以作为对象的一个标记，如果是false说明该对象没有数据，如果是true说明该对象有数据

}

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 (s.flag) {
                    //等待
                    try {
                        s.wait();//设置线程等待，释放锁s
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                
                if (x%2==0) {
                    s.name = "大明";
                    s.age = 14;
                }else {
                    s.name = "陈小宝";
                    s.age = 13;
                }
                x++;//x=1
                
                //此时对象有数据了
                s.flag = true;
                s.notify();//如果有等待的线程就唤醒，如果没有等待的线程，则没有任何效果
            }//在此时释放锁对象s
        }
        
    }

public class GetThread implements Runnable{
    private Student s;
    
    public GetThread(Student s){
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (s) {
                //判断对象有没有数据
                if (!s.flag) {
                    //等待设置线程给对象设置数据
                    try {
                        s.wait();//获取线程处于等待状态，释放锁对象s,在哪里跌倒在哪里爬起来
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                
                System.out.println(s.name+"--"+s.age);
                
                //当获取线程从学生对象中获取了数据之后，我们就默认他已经没有数据了，此时我们应该
                //继续让设置线程继续给学生对象设置信息
                s.flag = false;    
                s.notify();
            }
        }
        
    }

}

当此程序运行时就不会出现一个人名连续出现好多次的情况了；

结果如下：

这个代码有一些绕，要细细的揣摩才能想明白。

线程池
为什么要使用线程池？
程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，
尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。

线程池的特点：
线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。
在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池

线程池如何创建？
JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
public static ExecutorService newFixedThreadPool(int nThreads)

线程池的使用步骤：
1.创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2);

2.创建Runnable实例
MyRunnable my = new MyRunnable();

3.提交Runnable实例
pool.submit(my);
pool.submit(my);

4.关闭线程池
pool.shutdown();

练习代码：

public class MyCallable implements Callable{
    //也是一个任务，只不过这个任务需要执行的方法是call(),这个方法有返回值
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
        return null;
    }

}

 

public class ThreadPool {
    public static void main(String[] args) {
        //案例2：实现Callable接口实现线程池的使用
        //1.创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        
        //创建一个任务
        MyCallable my1 = new MyCallable();
        MyCallable my2 = new MyCallable();
        
        //3.提交任务
        pool.submit(my1);
        pool.submit(my2);
        
        //4.关闭线程池
        pool.shutdown();
        
    }

 

public class MyRunnbale implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
        
    }

}

public static void main(String[] args) {
        //线程池如何创建？
        //1.调用工厂类Executors
        //的public static ExecutorService newFixedThreadPool(int nThreads),返回一个线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(2);
        
        //2.提交给线程池两个任务，都是打印0-99
        //创建任务
        MyRunnbale my1 = new MyRunnbale();
        MyRunnbale my2 = new MyRunnbale();
        
        //3.提交任务
        pool.submit(my1);
        pool.submit(my2);
        
        //关闭线程池
        //void shutdown()
        pool.shutdown();

定时器
Timer
public Timer()构造
public void schedule(TimerTask task, long delay)延迟多久执行任务
public void schedule(TimerTask task,long delay,long period)延迟多久执行任务，并以后每隔多久执行一次
public boolean cancel()取消这个任务

public class TimerTest {
    public static void main(String[] args) {
        //需求：在10秒钟后，在控制台打印一句话，helloworld
        //public Timer()构造
        Timer t = new Timer();
        
        //public void schedule(TimerTask task, long delay)延迟多久执行任务
        t.schedule(new MyTimerTask(t), 10000);
        
        //public void cancel()终止此计时器
        //t.cancel();//如果在这里关闭的话，我们还没等任务执行完毕呢，计时器已经被关闭了
        
    }

}

//创建TimerTask的子类
class MyTimerTask extends TimerTask{
    private Timer t;
    public MyTimerTask(Timer t){
        this.t = t;
    }
    
    @Override
    public void run() {
        //此计时器任务要执行的操作。 
        System.out.println("helloworld");
        t.cancel();//当任务被执行完毕之后，关闭定时器
    }
    
}