Java----线程学习(多线程)

最新推荐文章于 2022-08-19 18:38:28 发布
最新推荐文章于 2022-08-19 18:38:28 发布
阅读量69 收藏
点赞数
分类专栏： JavaSE学习笔记 文章标签： 多线程 java thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46492246/article/details/117606313
版权

Java----线程学习(多线程)

1.线程的五个状态：
-创建状态：Thread t=new Thread()，创建了一个线程，此时该线程就是创建状态
-就绪状态()：当t线程调用了start()方法，线程立即进入就绪状态，在就绪状态队列中的线程不一定会立即执行，取决于cpu的调度
-运行状态：当cpu调度后，线程进入运行状态，执行重写的run方法的线程体代码块
-阻塞状态：当系统调用sleep(),wait,或者同步锁定时，线程进入阻塞状态，代码不往下执行，等待阻塞解除后，重新进入就绪状态，等待cpu的再次调度
-死亡状态：线程中断或结束，进入死亡状态后便不能再次启动了
JDK文档中这样描述：
线程可以处于以下状态之一:
●NEW 尚未启动的线程处于此状态。
●RUNNABLE 在Java虚拟机中执行的线程处于此状态。
●BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
●WAITING 正在等待另一个线程执行特定动作的线程处于此状态。
●TIMED WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
●TERMINATED 已退出的线程处于此状态。
一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。
测试代码：

package edu.ncu.dong.Thread.method;
//线程状态测试
public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
                try {
                    for (int i = 0; i < 5; i++) {
                        Thread.sleep(500);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        });
        //观察状态
        Thread.State state=thread.getState();
        System.out.println(state);//new
        thread.start();
        state=thread.getState();
        System.out.println(state);//runnable
        while (state!=Thread.State.TERMINATED){
            Thread.sleep(500);
            state=thread.getState();
            System.out.println(state);//TIMED_WAITING
        }
        //thread.start();//不能再启动
    }
}

结果如图：
在这里插入图片描述
注意的是已经处于死亡状态的线程不能重新启动：比如在main方法最后加上thread.start()就会报错：
在这里插入图片描述

2.线程常用方法

方法说明
setPriority(int newPriority)更改一个线程的优先级
static void sleep(long millis)指定当前线程休眠，参数以毫秒记
void jion()等待该线程终止
static void yield()暂停当前正在执行的线程对象，并执行其他线程
static void yield()暂停当前正在执行的线程对象，并执行其他线程
void interrupt()中断线程（不推荐使用）
boolean isAlive()测试线程是否处于活动状态

1）线程的终止
不推荐使用JDK提供的stop()，destroy()方法（已废弃），推荐让线程自己停止下来，建议使用一个标志位进行终止变量当flag=false,则终止线程运行。

package edu.ncu.dong.Thread;
import com.sun.scenario.effect.impl.sw.java.JSWBlend_SRC_OUTPeer;
//测试使用线程终止
public class TestStop implements Runnable{
    //1.设置一个标志位
    private boolean flag=true;
    @Override
    public void run() {
        int i=1;
        while(flag){
            System.out.println("这是第"+(i++)+"次");
        }
    }
    //2.设置一个自定义方法停止线程
    public void stop(){
        this.flag=false;
    }
    public static void main(String[] args) {
        TestStop test=new TestStop();
        new Thread(test).start();
        for (int i = 0; i < 500; i++) {
            System.out.println("main:"+"   "+i);
            if (i==400){
                //自己利用flag停止线程
                test.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

运行结果：
运行结果
2）进程休眠 sleep()
-sleep (时间)指定当前线程阻塞的毫秒数;
-sleep存在异常InterruptedException;
-sleep的时间达到后线程进入就绪状态;
-sleep可以模拟网络延时，倒计时等。
-每一个对象都有一个锁，sleep不会释放锁;
用sleep()模拟网络延时：这是个模拟的抢票系统

package edu.ncu.dong.Thread.method;
//模拟网络延时
public class TestSleep implements Runnable{
    private Integer tickets=5;//当前票数
    //线程执行体
    @Override
    public void run() {
        while (true) {
            if (tickets < 0)
                break;//这里先判断：至少还有一张票，才模拟下面的抢票操作
            System.out.println(Thread.currentThread().getName() + "执行了抢票操作,还有第" + tickets-- + "张票");
        }
    }
    public static void main(String[] args) {
        TestSleep test=new TestSleep();
        new Thread(test,"东东").start();//第二个参数是自定义线程的名字
        new Thread(test,"兰兰").start();
        new Thread(test,"丽丽").start();
    }
}

结果
结果中可以看出，这个“丽丽”线程明显执行时间过长，别的两位无法抢票，所以我们改一下代码，模拟网络延时：

public void run() {
        while (true) {
            if (tickets < 0)
                break;//这里先判断：至少还有一张票，才模拟下面的抢票操作
            try{
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "执行了抢票操作,还有第" + tickets-- + "张票");
        }
    }

执行结果友好得多:
在这里插入图片描述
3）线程礼让yield()
-礼让线程：让当前正在执行的线程暂停，但不阻塞（阻塞是转为阻塞态）
-作用：将线程从运行状态转为就绪状态，让cpu重新调度，礼让不一定成功!看CPU的调度
测试代码：

package edu.ncu.dong.Thread.method;
//测试yield方法
public class TestYield {
    public static void main(String[] args) {
        //这里就用lambda表达式简写了
        Runnable r=()->{
            System.out.println("线程："+Thread.currentThread().getName()+"  开始！");
            Thread.yield();//礼让
            System.out.println("线程："+Thread.currentThread().getName()+"  结束！");
        };
        new Thread(r,"T1").start();
        new Thread(r,"T2").start();
    }
}

结果：礼让成功
结果
再次运行结果：礼让失败
结果
4）合并线程jion（）
-这个方法很霸道：等待此线程执行完成后，再执行其他线程，其他线程阻塞
测试代码：

package edu.ncu.dong.Thread.method;
public class TestJoin {
    public static void main(String[] args) throws InterruptedException {
        Runnable r=()->{
            for (int i = 0; i < 5; i++) {
                System.out.println("正在执行vip线程"+i);
            }
        };
        Thread t=new Thread(r);
        t.start();//此时start之后，t线程就已经处于就绪状态（runnable状态）了，所以cpu是可以调度执行t的run代码块的
        for (int i = 0; i < 200; i++) {
            System.out.println("main线程执行中"+i);
            if(i==100)
                //此时i等于了100，执行了join方法，main进入阻塞，直到t线程结束，所所以可能出现的情况是：
                //t线程在join方法执行之前已经结束了(dead)，此时就不会调用t线程了
                t.join();
        }
    }
}

结果：
在这里插入图片描述
注意点：
代码中t.start()：此时start之后，t线程就已经处于就绪状态（runnable状态）了，所以cpu是可以调度执行t的run代码块的
而另一方面： t.join();此时i等于了100，执行了join方法，main进入阻塞，直到t线程结束，所以可能出现的情况是：t线程在join方法执行之前已经结束了(dead)，此时就不会调用t线程了。
如图：我把t线程的i调为5，此时线程t很快就结束了，而主线程就不会阻塞去调用t线程了。
在这里插入图片描述
5）线程优先级
Java提供一 个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。线程的优先级用数字表示，范围从1~10，默认为5。
方法名：void setPriority(int newPriority)
查看例子：

package edu.ncu.dong.Thread.method;

public class TestPriority {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+" its priority is : "+Thread.currentThread().getPriority());
        MyPriority myPriority=new MyPriority();
        Thread thread1=new Thread(myPriority);
        thread1.setPriority(6);
        Thread thread2=new Thread(myPriority);
        thread2.setPriority(7);
        Thread thread3=new Thread(myPriority);
        thread3.setPriority(8);
        Thread thread4=new Thread(myPriority);
        thread4.setPriority(9);
        Thread thread5=new Thread(myPriority);
        thread5.setPriority(10);//10是最大的优先级

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }
}

class MyPriority implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(1*1000);//延时，帮助cpu在调度其他线程时，当前线程还没结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            System.out.println(Thread.currentThread().getName()+" its priority is : "+Thread.currentThread().getPriority());
        }
    }
}

查看结果
在这里插入图片描述
可以发现，虽然Thread-4是最大优先级10，确实先于其他(除了主线程)线程运行了，但是看红色2处可以发现：并不一定优先级高就先执行，比如Thread-2先于Thread-3先执行，优先级只是会起到一定的作用。优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度。

6）守护线程（deamon）
线程分为用户线程和守护线程；虚拟机必须确保用户线程执行完毕(也就是说有用户线程存在时，JVM就会存活)，但是不用等待守护线程执行完毕。守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。如，后台记录操作日志，监控内存，垃圾回收等待…
查看例子：

package edu.ncu.dong.Thread.method;
/**
 * 测试守护线程
 */
public class TestDaemon {
    public static void main(String[] args) {
        /*
         * 神在守护我们来模拟守护线程
         */
        Godness godness=new Godness();//神
        We we=new We();//平凡人
        Thread threadGod=new Thread(godness);
        threadGod.setDaemon(true);//默认false，表示用户线程，true表示设置为守护线程
        Thread threadWe=new Thread(we);
        //启动线程
        threadGod.start();//守护线程
        threadWe.start();//用户线程
    }
}

class Godness implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println(" God bless us!");
        }
    }
}

class We implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 3000; i++) {
            System.out.println(" happy every day!");
        }
        System.out.println(" good bye !");
    }
}

我们查看运行结果：
在这里插入图片描述
这里各自获得cpu的调度执行
在这里插入图片描述
这里We线程(用户线程)执行结束，Godness线程还在执行
在这里插入图片描述
一段时间后，Godness也结束了，由于Godness线程是个While(true)死循环，不应该结束，但是由于它是守护线程，所以当没有用户线程存在时，守护线程也就随即结束。

nailaseb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-学习多线程总结上
12-22
所以在进程之上的进一步划分就变得非常的重要，而且性能也会有所提高，所有的线程一定要依附进程才能够存在，那么进程一旦消失，线程也一定会消失，但反过来不一定，而Java是支持多线程的开发语言之一。 2. 多线程的...
java并发编程—sleep()和wait()
l_010的博客
06-08 6183
java并发编程—sleep()和wait()
Java多线程基础
m0_61931988的博客
08-19 186
Java多线程基础
Java线程中的sleep方法详解
大白的成长之路
03-15 2万+
关于线程的sleep方法 static void sleep(long mills) 1、静态方法：Thread.sleep(1000); 2、参数是毫秒 3、作用：让当前线程进入休眠，进入“阻塞”状态，放弃占有CPU时间片，让给其他线程使用。 public class ThreadTest06 { public static void main(String[] args) { //让当前线程进入休眠，睡眠5秒 //当前线程是主线程！！! try
Java线程状态 初学 第三部分
qq_45346359的博客
04-19 164
文章目录线程状态停止线程线程休眠线程礼让Join线程状态观测线程优先级守护线程 线程状态 停止线程 方法 说明 setPriority(int newPriority) 更改线程的优先级 static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠 void join() 等待该线程终止 static void yield() 暂停当前正在执行的线程对象，并执行其他线程 void interrupt() 中断线程，别用这个方式
JAVA多线程并发
ma815841356的博客
09-18 4083
JAVA多线程并发1 JAVA并发知识库2 JAVA 线程实现/创建方式2.1 继承 Thread 类2.2 实现 Runnable 接口2.3 Callable 、Future 、ExecutorService 有返回值线程2.4 基于线程池的方式2.4.1 4种线程池2.4.1.1 newCachedThreadPool2.4.1.2 newFixedThreadPool2.4.1.3 new...
JAVA-多线程 所有文件
01-09
JAVA-多线程 所有文件
Java多线程-多线程相关概念
01-19
Java多线程--多线程相关概念
Java多线程-线程间的通信
最新发布
02-02
Java多线程--线程间的通信
Java多线程-线程的生命周期
01-27
Java多线程--线程的生命周期
java 线程的安全启停，通过标志位
闲書的博客
05-26 1651
java 线程的安全启停，通过标志位 在java线程中 stop() 方法，不推荐使用，为过期API,那么怎么安全的停止、退出线程？ 可以通过使用标志位的方式实现： 我们定义一下结果参数，来控制线程的启停、退出 private boolean start = false; //启动标识 private boolean stop = false; //暂停标识 private b...
java多线程之使用标志位将线程停止
moerduo0的博客
02-14 837
线程停止的方式 1.建议线程正常停止-----》利用次数，不建议死循环 2.建议使用标志位-----》设置一个标志位 3.不要使用stop或者destroy等过时或者jdk不建议的方法 *这里我们使用标志位：当主线程到第90次时停止子线程 //测试stop //1.建议线程正常停止-----》利用次数，不建议死循环 //2.建议使用标志位-----》设置一个标志为 //3.不要使用stop或者destroy等过时或者jdk不建议的方法 public class TextThread5 implements
java 线程 中断标志位
pf1234321的专栏
05-19 3231
课程素材来自 http://enjoy.ke.qq.com/    版权所有java线程中，线程中断方法详解：线程自然终止：自然执行完或抛出未处理异常stop()，resume(),suspend()已不建议使用，stop()会导致线程不会正确释放资源，suspend()容易导致死锁。java线程是协作式，而非抢占式调用一个线程的interrupt() 方法中断一个线程，并不是强行关闭这个线程，只...
Java 中的 sleep 方法
学习笔记
05-11 4万+
Sleep可以让当前线程进行休眠，有如下两个方法： public static void sleep​(long millis) throws InterruptedException ，mills 毫秒 public static void sleep​(long millis, int nanos) throws InterruptedException ，millis 毫秒， nan...
java中sleep（）的用法
u011285162的专栏
08-08 6232
 Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。 当线程睡眠时，它睡在某个地方，在苏醒之前不会返回到可运行状态。 当睡眠时间到期，则返回到可运行状态。   线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。
java基础篇之 休眠(sleep、延时执行)
热门推荐
晓果博客
06-17 4万+
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。 import java.util.*; public class SleepDemo { public static void main(String args[]) { try { Syste...
java中线程睡眠sleep()方法介绍——Java日常学习笔记（三）
weixin_48610702的博客
08-10 1万+
java中线程睡眠sleep()方法介绍 1、方法介绍 sleep(long millis) 线程睡眠 millis 毫秒 sleep(long millis, int nanos) 线程睡眠 millis 毫秒 + nanos 纳秒 2、如何调用sleep 因为sleep()是静态方法，所以最好的调用方法就是 Thread.sleep()。 3、在哪里写sleep更合理？ 线程的sleep方法应该写在线程的run()方法里，就能让对应的线程睡眠。如下面代码： public class Thre
Java之【线程通信】--标志位练习
weixin_30525825的博客
05-02 119
* 写两个线程，一个线程打印1-52，另一个线程答应字母A-Z。 * 打印顺序为12A34B56C……5152Z。通过使用线程之间的通信协调关系。 注：分别给两个对象构造一个对象o，数字每打印两个或字母每打印一个就执行o.wait()。 在o.wait()之前不要忘了写o.notify() 代码： 方法一：直接写 package Homework; pub...
jmu-java-07多线程-thread
03-16
JMU Java 07 多线程 (Thread) 是指在 Java 语言中使用多个线程来同时执行多个任务的技术。通过使用多线程，可以提高程序的并行处理能力，加快程序的执行速度，提高程序的效率。在 Java 中，多线程可以通过继承 java....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值