java学习【知识点及代码16】

一：线程中的一些方法(线程中存在的现象)

1.1 线程加入    public final void join()    等待该线程中止，其他线程才能继续抢着执行

package day16.edu_01;public class Test {    public static void main(String[] args) {        //创建3个线程        MyThread t1 = new MyThread();        MyThread t2 = new MyThread();        MyThread t3 = new MyThread();        //给线程起名字        t1.setName("小白");        t2.setName("小黑");        t3.setName("小红");        //开启线程        t1.start();        //线程加入        try {            t1.join();        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }        t2.start();        t3.start();         }}

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

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

package day16.edu_02;public class Test {    public static void main(String[] args) {        //创建2个线程        MyThread t1 = new MyThread();        MyThread t2 = new MyThread();        //给线程设置名字        t1.setName("小白");        t2.setName("小黑");        //开启线程        t1.start();        t2.start();    }}

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

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

package day16.edu_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()));        //休眠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()));    }}

package day16.edu_03;public class Test {    public static void main(String[] args) {        //创建线程对象        MyThread t = new MyThread();        //开启线程        t.start();        try {            Thread.sleep(3000);            //public final void stop():直接杀死            t.stop();            //public void interrupt():直接杀死，在死前，还可以有遗言。            //t.interrupt();        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }    }}

1.4 线程休眠static void sleep(long millis) 线程睡一会

二：线程的生命周期(画图讲解)，面试题

1.新建2.就绪3.运行4.有可能阻塞5.死亡

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

四：案例：以给学生设置和获取姓名和年龄为例，演示线程通信问题

线程间通讯：
资源：Student
设置数据线程：SetThread
获取数据线程：GetThread
测试类：StudentDemo

问题1：控制台出现的结果是:null—0

设置和获取线程使用的学生资源不是同一个。如何解决这个问题呢?    把资源作为构造参数传递即可。

问题2：产生了2个问题

A:相同的数据出现了多次    CPU的一点点时间片就足够我们的程序执行很多次B:数据出现了问题(数据安全问题)    a:是否是多线程环境        是    b:是否有共享数据        是    c:是否有多条语句操作共享数据        是既然我们知道它是出现了数据安全问题，我们就应该来解决它。如何解决呢?加锁

问题3：加了锁以后，数据还是有问题

A:多个线程都要加锁B:多个线程加的锁必须是同一把锁

package day16.edu_04;public class Student {    String name;    int age;}

package day16.edu_04;public class SetThread implements Runnable{    //Student s = new Student();    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.name="小白";                    s.age=12;                }else{                    s.name="小黑";                    s.age=13;                }                x++;            }        }       }}

package day16.edu_04;public class GetThread implements Runnable{    //Student s = new Student();    private Student s;    public GetThread(Student s){        this.s = s;    }    @Override    public void run() {        while (true) {            synchronized (s) {                System.out.println(s.name+"  "+s.age);            }                   }           }}

package day16.edu_04;public class Test {    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();         }}

五：将上述代码使用等待唤醒机制改进，实现礼让效果

package day16.edu_05;public class Student {    String name;    int age;    boolean flag;}

package day16.edu_05;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();                    } catch (InterruptedException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                }else {                    if (x%2==0) {                        s.name="小白";                        s.age=12;                    }else{                        s.name="小黑";                        s.age=13;                                           }                    x++;                    //此时对象有数据了                    s.flag=true;                    s.notify();                }            }        }           }}

package day16.edu_05;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();                    } catch (InterruptedException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                }else{                    System.out.println(s.name+"  "+s.age);                    //当获取线程从学生对象中获取了数据之后，我们就默认他已经没有数据了，此时我们应该                    //继续让设置线程继续给学生对象设置信息                    s.flag=false;                    s.notify();                    }                   }                   }           }}

package day16.edu_05;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();         }}

六：将上述代码继续优化
1.私有化Student类的成员变量
2.在类的内部提供设置和获取的同步方法

package day16.edu_06;public class Student {    private String name;    private int age;    private boolean flag;    //提供公共的方法设置信息    public synchronized void setInfo(String name,int age){        if(this.flag){            try {                this.wait();            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }        }            //没有值的话，在这里给对象设置数据            this.name=name;            this.age=age;            //更改标记，唤醒获取线程获取数据            this.flag=true;            this.notify();    }    public synchronized void getInfo(){        if(!this.flag){            try {                this.wait();            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }        }else{            //有数据，取数据            System.out.println(this.name+"  "+this.age);            //取完数据之后，就没有数据了            this.flag=false;            this.notify();        }    }}

package day16.edu_06;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) {            if (x%2==0) {                s.setInfo("小白", 13);            } else {                s.setInfo("小黑", 14);            }            x++;        }           }}

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

package day16.edu_06;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();    }}

七：线程组

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

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

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

package day16.edu_07;public class Test {    public static void main(String[] args) {        // 案例1：创建线程获取对应的线程组对象，并获取名称        MyThread m1 = new MyThread();        MyThread m2 = new MyThread();        //获取上面两个线程对应的线程组对象        ThreadGroup tg1 = m1.getThreadGroup();        ThreadGroup tg2 = m2.getThreadGroup();        //获取线程组对象的名称        System.out.println(tg1.getName());        System.out.println(tg2.getName());        System.out.println("-------------------------");        //案例2：创建线程组对象，给线程分配线程组        //public ThreadGroup(String name)        ThreadGroup tg = new ThreadGroup("大白");        //public Thread(ThreadGroup group,Runnable target)        Thread t3 = new Thread(tg, new MyRunnable());        Thread t4 = new Thread(tg, new MyRunnable());        //获取t3和t4的线程组对象        ThreadGroup tg3 = t3.getThreadGroup();        ThreadGroup tg4 = t4.getThreadGroup();        System.out.println(tg3.getName());        System.out.println(tg4.getName());    }}

八：线程池

为什么要使用线程池？

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

线程池的特点：

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

线程池如何创建？

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

package day16.edu_08;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class ThreadPool {    public static void main(String[] args) {        //线程池如何创建？        //1.调用工厂类Executors        //的public static ExecutorService newFixedThreadPool(int nThreads),返回一个线程池对象        ExecutorService pool = Executors.newFixedThreadPool(2);        //2.提交给线程池两个任务，都是打印0-9        //创建任务        MyRunable m1 = new MyRunable();        MyRunable m2 = new MyRunable();        //3.提交任务        pool.submit(m1);        pool.submit(m2);        //关闭线程池        pool.shutdown();    }}

package day16.edu_08;public class MyRunable implements Runnable{    @Override    public void run() {        for (int i = 0; i < 10; i++) {            System.out.println(Thread.currentThread().getName()+"  "+i);        }    }}

线程池的使用步骤：

1.创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2);

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

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

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

案例1：实现Runnable接口实现线程池的使用
案例2：实现Callable接口实现线程池的使用

package com.edu_09;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;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();    }}

package com.edu_09;import java.util.concurrent.Callable;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;    }}

案例3：实现Callable接口实现线程池的使用，实现多线程求和，1-10之和，1-100之和

package day16.edu_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;    }}

package day16.edu_10;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;//案例3：实现Callable接口实现线程池的使用，实现多线程求和，1-10之和，1-100之和public class Test {    public static void main(String[] args) throws Exception {        //1.创建线程池        ExecutorService pool = Executors.newFixedThreadPool(2);        //2.创建任务对象，创建任务对象的同时，将参数进行传递        MyCallable m1 = new MyCallable(1, 10);        MyCallable m2 = new MyCallable(1, 100);        //3.提交任务<T> Future<T> submit(Callable<T> task)        Future<Integer> s1 = pool.submit(m1);        Future<Integer> s2 = pool.submit(m2);        //V get()如有必要，等待计算完成，然后获取其结果。        System.out.println(s1.get());        System.out.println(s2.get());        //4.关闭线程池        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()放的是所要执行的任务代码

案例1：演示以上方法的使用

package com.edu_11;import java.util.Timer;import java.util.TimerTask;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();//当任务被执行完毕之后，关闭定时器    }   }

package com.edu_11;import java.util.Timer;import java.util.TimerTask;//public void schedule(TimerTask task,long delay,long period)//延迟多久执行任务，并以后每隔多久执行一次public class TimerTest2 {    public static void main(String[] args) {        //延迟5秒钟，打印，我爱中国，以后每隔一秒打印一次        Timer t = new Timer();        t.schedule(new MyTimerTask2(), 5000, 1000);        /**         * 参数1：要执行的任务         * 参数2：延迟多久执行         * 参数3：执行一次之后，每隔多久重复执行         */    }}class MyTimerTask2 extends TimerTask{    @Override    public void run() {        System.out.println("我爱中国");    }   }

案例2：定时删除文件
所用方法：schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务

package com.edu_12;import java.io.File;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Timer;import java.util.TimerTask;public class Test {    public static void main(String[] args) throws Exception {        /**         * 案例2：定时删除文件(需要在15：58：00 删除D：//a.txt文件)         * 所用方法：schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务         * 时间点：16：30：00         * 任务：删除D：//a.txt文件         */        //创建定时器        Timer t = new Timer();        String time = "2017-05-20 16:31:00";        Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(time);        //所用方法：schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务        t.schedule(new MyTimerTask(), date);    }}class MyTimerTask extends TimerTask{    @Override    public void run() {        //任务：删除D：//a.txt文件        File file = new File("D://a.txt");        file.delete();    }   }