Java学习笔记（十六）--线程

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

线程中的一些方法

1.线程加入：
public final void join()
join()方法的作用：等待该线程中止，其他线程才能继续抢着执行。

2.线程礼让：
public static void yield()
yield()方法的作用：暂停当前正在执行的线程对象，并执行其他线程。
理论上会让线程之间的执行更加和谐，但是实际上做不到。

3.线程死亡：

public final void stop()
public vois interrupt()

stop()方法的作用：直接杀死线程，后面的代码就不会执行了。
interrupt()方法的作用：直接杀死线程，但是在线程死亡之前，还可以有遗言，后面的代码会执行。

下面的代码的执行结果可以清楚的看到这两个方法之间的区别：
（1）调用stop()方法杀死线程：

package com.edu_01;

import java.text.SimpleDateFormat;
import java.util.Date;

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) {
            // 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);
            //在线程休眠的时候杀死这个线程
            //调用stop()方法将线程直接杀死,上面有一条横线表示已经过时，但是还是可以使用
            mt.stop();

        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

运行结果：
这里写图片描述

（2）调用interrupt()方法杀死线程：

package com.edu_01;

import java.text.SimpleDateFormat;
import java.util.Date;

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

}

运行结果：
这里写图片描述

4.线程休眠：
static void sleep(long mliils)
sleep()方法的作用：让线程睡一会。

sleep()和wait()方法的区别：
sleep()：线程休眠，会自己醒来，线程休眠的过程中不会释放掉手里的锁。
wait()：线程等待，不会自己醒来，需要被唤醒，等待的过程中会释放掉手里的锁。

线程的生命周期

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

线程的生命周期图解：

这里写图片描述

线程间通信

1.线程间通信问题：多个线程对同一个资源进行操作，有进有出。

2.生产者消费者问题：
单生产单消费：生产和消费都是一个线程。
多生产多消费：生产和消费都是多个线程。

案例：以给学生设置和获取姓名和年龄为例，演示线程通信问题。
基于学生对象的线程间通信问题图解：
这里写图片描述
可以看出这是一个单生产单消费问题。

package com.edu_01;
//学生类
class Student {
    String name;
    int age;

}
//设置线程
class SetThread extends Thread{

    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=22;
                } else {
                    s.name="李四";
                    s.age=23;
                }
                x++;
            }
        }
    }
}
//获取线程
class GetThread extends Thread{
    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);
            }
        }
    }
}

public class StudentDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();

        //创建设置线程和获取线程并开启
        SetThread st = new SetThread(s);
        GetThread gt = new GetThread(s);

        st.start();
        gt.start();
    }

}

运行结果：
这里写图片描述

可以看出上述运行结果不够和谐，我们可以加入等待唤醒机制，实现礼让效果：

package com.edu_01;
//学生类
class Student {
    String name;
    int age;
    boolean flag;//用来判断对象中是否有数据

}
//设置线程
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=22;
                } else {
                    s.name="李四";
                    s.age=33;
                }
                x++;

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

    }

}
//获取线程
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();
            }
        }

    }


}

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.线程组：Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
默认情况下，所有线程都属于主线程组。

2.获取线程对应的线程组对象：public final ThreadGroup getThreadGroup()

3.给线程组设置分组：Threa(ThreadGroup,Runnable target)

需求1：创建线程获取对应的线程组对象，并获取名称。
需求2：创建线程组对象，给线程分配线程组。

package com.edu_01;

class MyThread extends Thread{
        public void run() {

        }

}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub

    }

}

public class Test {
    public static void main(String[] args) {
        //需求1：创建线程获取对应的线程组对象，并获取名称
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();

        //获取上面两个线程对应的线程组对象
        ThreadGroup tg1 = mt1.getThreadGroup();
        ThreadGroup tg2 = mt2.getThreadGroup();

        //获取线程组对象的名称
        System.out.println(tg1.getName());//main，默认情况下每一个线程都属于主线程组
        System.out.println(tg2.getName());

        System.out.println("------------------------");
        //需求2：创建线程组对象，给线程分配线程组
        ThreadGroup tg = new ThreadGroup("线程组");

        //public Thread(ThreadGroup group,Runnable target)
        Thread t1 = new Thread(tg,new MyRunnable());
        Thread t2 = new Thread(tg,new MyRunnable());

        //获取上面两个对象的线程组对象
        ThreadGroup tg3 = t1.getThreadGroup();
        ThreadGroup tg4 = t2.getThreadGroup();

        //获取线程组对象的名称
        System.out.println(tg3.getName());
        System.out.println(tg4.getName());

    }

}

运行结果：
这里写图片描述

线程池

1.线程池：可以理解为一个装线程的池子。

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

3.线程池的特点：线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。

4.线程池的创建：利用Executors工厂类，调用public static ExecutorService newFixedThreadPool(int nThreads)方法。

5.线程池的使用步骤：
（1）创建线程池对象：
ExecutorService pool = Executors.newFixedThreadPool(2);
（2）创建任务：
MyRunnable my = new MyRunnable();
（3）提交任务：
pool.submit(my);
pool.submit(my);
（4）关闭线程池：
pool.shutdown();

需求：实现Runnable接口实现线程池的使用。

package com.edu_01;

class MyThread implements Runnable{

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

    }

}
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPool {
    public static void main(String[] args) {
        //1.利用工厂类Executors创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);

        //2.创建两个任务，打印0到99
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();

        //3.提交任务给线程池
        pool.submit(mt1);
        pool.submit(mt2);

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

}

需求：实现Callable接口实现线程池的使用。

package com.edu_01;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyCallable implements Callable{

    @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) {
        //1.创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);

        //2.创建两个任务
        MyCallable mc1 = new MyCallable();
        MyCallable mc2 = new MyCallable();

        //3.提交任务
        pool.submit(mc1);
        pool.submit(mc2);

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

}

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

package com.edu_01;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

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 = start; i < end+1; i++) {
            sum+=i;
        }
        return sum;
    }

}

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

        //2.创建任务并传参
        MyCallable mc1 = new MyCallable(1,10);
        MyCallable mc2 = new MyCallable(1,100);
        MyCallable mc3 = new MyCallable(1,1000);

        //3.提交任务<T> Future<T> submit(Callable<T> task)
        Future<Integer> res1 = pool.submit(mc1);
        Future<Integer> res2 = pool.submit(mc2);
        Future<Integer> res3 = pool.submit(mc3);

        V get()如有必要，等待计算完成，然后获取其结果。
        System.out.println(res1.get());
        System.out.println(res2.get());
        System.out.println(res3.get());

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

}

定时器

1.Timer：

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

对于schedule()方法：
* 参数1：要执行的任务
* 参数2：延迟多久执行
* 参数3：执行一次之后，每隔多久重复执行
*
2.TimerTask：

public abstract void run()//放的是所要执行的任务代码
schedule(TimerTask task, Date time) //安排在指定的时间执行指定的任务

需求：在10秒钟后，在控制台打印一句话，helloworld。

package com.edu_01;

import java.util.Timer;
import java.util.TimerTask;

public class TimerTest {
    public static void main(String[] args) {
        Timer t = new Timer();

        t.schedule(new MyTimerTask(t),1000);

        //public void cancel()终止此计时器
        //t.cancel();//如果在这里关闭的话，我们还没等任务执行完毕呢，计时器已经被关闭了
    }

}
class MyTimerTask extends TimerTask{
    private Timer t;

    public MyTimerTask(Timer t){
        this.t=t;
    }
    @Override
    public void run() {
        //此计时器任务要执行的操作
        System.out.println("helloworld");

        //关闭计时器
        t.cancel();
    }

}

需求：延迟5秒钟，打印，我爱中国，以后每隔一秒打印一次。

package com.edu_01;

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) {
        Timer t = new Timer();

        t.schedule(new MyTimerTask2(t),5000,1000);
    }

}
class MyTimerTask2 extends TimerTask{
    private Timer t;

    public MyTimerTask2(Timer t){
        this.t=t;
    }
    @Override
    public void run() {
        System.out.println("我爱中国");

    }

}
yangruxi
关注
专栏目录
Java学习笔记----如何保证线程安全
weiqu4386的博客
01-04 1318
如何保证线程安全 文章目录如何保证线程安全前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import n
Java学习笔记----第二部分：java高级编程（尚硅谷宋红康老师讲授）
m0_52574098的博客
10-22 2012
java基础中多线程学习、java反射、泛型和常用类、IO流、网络编程、枚举类与注解
Java学习笔记-多线程
cyh0503的博客
07-08 2839
并发与并行 并发：指两个或多个事件在同一个时间段内发生 并行：指两个或多个事件在同一时刻发生（同时发生） 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单CPU系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 而在多个CPU系统中，则这些可以并发执行的程序便可以分配到多...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
B站韩顺平java学习笔记（十六）-- 多线程基础章节
LW_20180806的博客
04-11 3407
一 线程介绍 1 线程相关概念 （1）程序 是为完成特定任务、用某种语言编写的一组指令的集合（简单说就是写的代码）。 （2）进程 ① 进程是指运行中的程序，比如使用的QQ，就启动了一个进程，操作系统回味该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将会为迅雷分配新的内存空间。 ② 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程。 （3）什么是线程 ① 线程是由进程创建的，是进程的一个实体； ② 一个进程可以拥有多...
Java学习笔记-线程状态
cyh0503的博客
07-08 2723
线程状态概述 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在APi中java.lang.Thread.State这个枚举中给出了六种线程状态： 这里先列出哥哥线程状态发生的条件，下面将会对每种状态进行详细解析 线程状态 导致状态发生条件 NEW（新建） 线程刚被创建，但是并未启动。还没调用start方法。 R...
Java学习笔记-线程安全
cyh0503的博客
07-08 2593
线程安全 如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。 现在通过一个案例来延时线程的安全问题： 电影院卖票，一共100张票数，我们现在通过3个窗口来卖100张票： 模拟票： public class Ticket implements Runnable { private in...
Java学习笔记--导航
Switch的博客
11-13 1万+
Java入门(1)——http://blog.csdn.net/q547550831/article/details/49533977 Java入门(2)——http://blog.csdn.net/q547550831/article/details/49818745
【并发编程】（学习笔记-Java线程）-part2
最新发布
2401_84407867的博客
04-20 946
由于篇幅有限，这里就不一一罗列了，20道常见面试题（含答案）+21条MySQL性能调优经验小编已整理成Word文档或PDF文档还有更多面试复习笔记分享如下《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！bject obj;自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。
Java多线程学习笔记 - 1
涞公子的博客
03-13 2487
多任务 概述： 多任务就是同时运行多个任务。 好处： 充分利用了CPU的资源，提高了代码的执行效率。 执行方式： 并发：在一段时间内交替去执行多项任务【任务数 > 核数】 并行：多个计算机内核一起执行任务，一个内核负责执行一个任务【任务数 <= 核数】 实现方式： 多线程或多进程。 进程与线程介绍： 进程 概述： 线程 概述： 进程与线程之间的关系 一个进程内含有一个或多个线程，但至少含有一个线程。 ...
JAVA并发编程实践-线程安全-学习笔记
07-20
在Java并发编程中，线程安全是一个至关重要的概念，它涉及到多线程环境下对共享数据的正确管理和访问。线程安全意味着当多个线程同时访问一个对象或数据时，对象的状态能够保持一致性和完整性，不会因为并发导致数据...
JAVA并发编程实践-线程执行-学习笔记
07-21
占式线程调度是Java和大多数现代操作系统采用的线程调度策略。在这种模式下，操作系统决定何时以及哪个线程将获得CPU的执行时间。线程的执行不是由线程自身控制，而是由操作系统通过时间片轮转或者优先级调度等方式...
基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip
01-08
基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip 基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码.zip 基于java的开发源码-java多线程反射泛型及正则表达式学习笔记和源码....
JAVA并发编程实践-线程对象与组合对象-学习笔记
07-20
使用java.util.concurrent类库构造安全的并发应用程序的基础。共享其实就是某一线程的数据改变对其它线程可见，否则就会出现脏数据。
多线程-狂神说Java学习笔记
07-19
本学习笔记将深入探讨Java多线程的相关知识，包括其原理、实现方式、同步机制以及常见问题。 ### 一、多线程的基本概念 多线程是指在一个程序中存在两个或更多的执行线程，这些线程共享同一内存空间，但各自拥有...
Java实现--登录和注册案例（把用户信息存进集合）
yangruxi的博客
05-04 2万+
登录和注册案例的分析： 我们在完成一个需求时，需要面向对象，我们必须找到能完成某个功能的类，接着调用里面的方法来完成它。而这些类我们要进行分包，在不同包下实现，Java中的分包： com.edu.domain — 标准的Java描述类 com.edu.dao — 存放的是接口 com.edu.daoimpl — 存放的是接口的实现类 com.edu.util — 对对象进行操作的工具类
Java实现--登录和注册案例（IO流实现）
yangruxi的博客
05-18 9460
案例分析： 我们之前做过的登录注册案例是把用户信息存进集合里，要用IO流实现的话，就是要把用户信息存入文件中。登录注册两个功能的具体实现是在用户操作类中，所以我们只需要在用户操作类中把之前用户信息存进集合改为存进文件就可以了。用到的类的详细分解： （1）用户类（User）：用户名，密码，邮箱，电话号码等等各种注册时会用到的东西。我们在实现这个登录和注册案例的时候只需要用户名和密码就够了。这是一个
Java实现--模拟斗地主的洗牌和发牌
yangruxi的博客
05-09 3478
案例分析： 我们需要模拟斗地主过程中的洗牌、发牌和看牌。而且要求牌是排好序的。1.每张扑克牌都有花色和点数，所以我们可以先把花色和点数存进两个字符串数组，然后再存进集合里，而因为我们后面涉及到对牌进行洗牌还有排序等等，所以我们选择TreeMap集合来存储，键是扑克牌的编号，值是扑克牌的花色和点数（把花色和点数拼接成一个字符串）。2.洗牌洗的是编号，我们再用ArrayList集合来存储牌的编号，调用
Java实现--游戏次数案例（IO流文件存储游戏次数）
yangruxi的博客
05-18 2795
案例： 有一个猜数字小游戏，需要限制玩家的游戏次数，当超过5次时，提示玩家：免费游戏次数已用完，请付费。案例分析： 可以用文件来存储游戏次数，玩家每玩一次游戏，游戏次数加1，同时更新文件中存储的数据，当文件中的数据大于5的时候，就可以给出提示：免费游戏次数已用完，请付费。实现步骤： 1.创建一个文件，存储游戏次数 2.创建一个Propeties集合 3.把文件中的元素添加到集合中 4.把
"JAVA并发编程实践-线程关闭与取消-学习笔记
《JAVA并发编程实践-线程的关闭与取消-学习笔记》 在Java中，并发编程需要处理线程的关闭与取消问题。由于Java没有提供任何机制来安全强制线程停止当前工作，因此Thread.stop和Thread.suspend方法存在严重的缺陷，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值