java学习笔记（三十二）java线程2

最新推荐文章于 2017-06-01 14:23:33 发布
最新推荐文章于 2017-06-01 14:23:33 发布
阅读量219 收藏
点赞数
分类专栏： java 文章标签： java 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ll_best/article/details/72675366
版权

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

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();

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

1.2 线程礼让
public static void yield():暂停当前正在执行的线程对象，并执行其他线程。
作用：让线程间的执行更和谐一些，但是实际上做不到。

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

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()));
    }

}

public class Test {
    public static void main(String[] args) {
        //创建线程对象
        MyThread mt = new MyThread();
        //开启线程对象
        mt.start();

        //在线程处于睡眠的过程中将他杀死

        try {
            Thread.sleep(3000);
            //interrupt():直接杀死，在死前，还可以有遗言。
            mt.interrupt();//线程被杀死之后会将后面的代码执行完毕之后，再死去

        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }       
    }
}
/*结果：
开始时间：11:20:21
我被杀死了
结束时间：11:20:24
*/

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

二：线程的生命周期
1.新建
2.就绪
3.运行
4.有可能阻塞
5.死亡
这里写图片描述
三：线程间通信(生产消费者问题)：不同类型线程针对同一个资源的操作
通过一个案例来说明问题：
以给学生设置和获取姓名和年龄为例，演示线程通信问题
线程间通讯：
资源：Student
设置数据线程：SetThread
获取数据线程：GetThread
测试类：StudentDemo
Student.java

public class Student {
    String name;
    int age;
}

SetThread.java

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 = 50;
                }else {
                    s.name = "陈冠希";
                    s.age = 35;
                }
                x++;
            }

        }

    }

}

GetThread.java

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);  
            }
        }
    }
}

StudentDemo.java

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的一点点时间片就足够我们的程序执行很多次
怎么解决这个问题呢？
将上述代码使用等待唤醒机制改进，实现礼让效果
在Student类中加一个boolean类型的成员变量Flag用来控制
Student.java

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

}

修改GetThread.java和SetThread.java
GetThread.java
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);//刘嘉玲--50
                                                  //冠希--35
                                                  //刘嘉玲--50

            //当获取线程从学生对象中获取了数据之后，我们就默认他已经没有数据了，此时我们应该
            //继续让设置线程继续给学生对象设置信息
            s.flag = false; 
            s.notify();
        }
    }

}

}
SetThread.java

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 = 50;
                }else {
                    s.name = "冠希";
                    s.age = 35;
                }
                x++;//x=1

                //此时对象有数据了
                s.flag = true;
                s.notify();//如果有等待的线程就唤醒，如果没有等待的线程，则没有任何效果
            }//在此时释放锁对象s
        }

    }

}

来实现礼让效果
结果：
这里写图片描述
四.线程池
为什么要使用线程池？
程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，
尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。

线程池的特点：
线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。
在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();
练习：实现Runnable接口实现线程池的使用
MyRunnbale.java

public class MyRunnbale implements Runnable {

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

ThreadPool.java

public class ThreadPool {
    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();    
    }
}

结果：
这里写图片描述
练习2：实现Callable接口实现线程池的使用，实现多线程求和，1-10之和，1-100之和
MyCallable.java

public class MyCallable implements Callable<Integer>{//这里面的泛型就是call()方法返回值的类型
    private int start;
    private int end;

    public MyCallable(int start,int end){
        this.start = start;
        this.end = end;
    }

    @Override
    public Integer call() throws Exception {
        //在这里求取start--end之间的和
        int sum = 0;
        for (int i = start; i < end+1; i++) {
            sum+=i;
        }
        return sum;
    }
}

Test.java

public class Test {
    public static void main(String[] args) throws Exception{
        //1-10之和，1-100之和
        //1.创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);

        //2.创建任务对象，创建任务对象的同时，将参数进行传递
        MyCallable my1 = new MyCallable(1,10);
        MyCallable my2 = new MyCallable(1, 100);
        MyCallable my3 = new MyCallable(1, 1000);

        //3.提交任务<T> Future<T> submit(Callable<T> task)
        Future<Integer> res = pool.submit(my1);
        Future<Integer> res2 = pool.submit(my2);
        Future<Integer> res3 = pool.submit(my3);

        //V get()如有必要，等待计算完成，然后获取其结果。 
        System.out.println(res.get());
        System.out.println(res2.get());
        System.out.println(res3.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()放的是所要执行的任务代码

练习：定时删除文件

public class Test {
    public static void main(String[] args) throws Exception {
        /**
         * 定时删除文件(需要在13：10：00 删除D：//a.txt文件)
         * 所用方法：schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务
         * 时间点：13：10：00
         * 任务：删除D：//a.txt文件
         */
        //创建定时器
        Timer t = new Timer();

        String time = "2017-05-24 13:10: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();
    }   
}
ll_best
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java struts2学习笔记之线程安全
09-02
总结来说，Java Struts2通过为每个请求创建新的Action实例，解决了Servlet的线程安全问题。但开发者仍然需要关注Action所依赖的对象的线程安全，以确保整个应用程序的稳定性和数据一致性。在编写Struts2应用时，遵循...
java学习笔记 – 线程安全问题操作实例
12-22
二.线程与进程 进程：就是内存中运行的应用程序。每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
java学习笔记
12-22
Java学习笔记涵盖了大量的Java基础知识，包括面向对象编程和高级特性。以下是对这些知识点的详细解释： **基础语法** 1. **数据类型**：Java有基本数据类型和引用数据类型。基本数据类型包括整型（byte, short, int...
java学习笔记（八）break与contune的区别
ll_best的博客
04-06 2192
break与contune的区别
java学习笔记（二十）java常用类
ll_best的博客
04-26 681
java常用类
java学习笔记（十三）二维数组
ll_best的博客
04-13 585
二维数组
java学习笔记（二十五）模拟斗地主发牌与洗牌
ll_best的博客
05-11 581
java模拟斗地主发票与洗牌
java学习笔记（二十四）注册登录系统
ll_best的博客
05-04 574
注册登录系统
java学习笔记（七）流程控制之循环语句
ll_best的博客
04-06 522
流程控制之循环语句：
java学习笔记（三十一）i/o流实现登陆注册案例
ll_best的博客
05-18 495
登陆注册案例i/o流版
java学习笔记（一）java语言介绍
ll_best的博客
04-06 489
java语言介绍1:常用的DOS命令A:盘符切换 盘符: 然后回车 B:列出当前目录下的文件以及文件夹 dir 然后回车 C:创建目录(文件夹) 了解 md 目录名称 D:删除目录 了解 rd 目录名称 E:进入指定目录 a:单级目录 cd 目录名称 b:多级目录 cd 多级目录名称,目录间用\隔开的 F:回退指
java学习笔记（二十七）设计模式
ll_best的博客
05-11 488
设计模式
java学习笔记（十四）冒泡与选择排序
ll_best的博客
04-12 419
冒泡与选择排序
java学习笔记（六）流程控制之选择语句
ll_best的博客
04-06 411
流程控制之选择语句
mysql语句（一）
ll_best的博客
06-01 384
数据库
java学习笔记（十五）继承
ll_best的博客
04-13 373
继承
java学习笔记（四）java中的运算
ll_best的博客
04-06 370
java中的运算
Java学习笔记：三大体系与面向对象特性解析
这篇Java学习笔记涵盖了Java的基础知识，包括其三大体系、特点、主要的开源网站以及面向对象编程的特征。以下是详细的解析： 1. **Java的三大体系** - **J2SE (Java to Standard Edition)**：这是Java的基础版本，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值