线程的初步使用

最新推荐文章于 2023-05-11 09:46:02 发布
最新推荐文章于 2023-05-11 09:46:02 发布
阅读量247 收藏 1
点赞数
分类专栏： java线程 知识总结 文章标签： java线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32844875/article/details/78524938
版权

什么是线程？

java中，创建线程类就两个途径。实现Runnable接口，扩展Thread类。一般基于单继承多接口的原因，推荐使用Runnable接口！运行中的进程切换叫做“上下文切换”
最简单的线程例子 
class ThreadDemo{
    public static void main(String[] args){
        new NewThread();
        try{
//主线程执行的代码
            for (int i= 5; i>0; i++){
                System.out.println("Main Thtrad :" +i);
            }
        } catch (Exception e){
            System.out.println("Main thread interruped.");
        }
        System.out.println("Main thred exiting.");
    }
}
class NewThread implements Runnable{
    Thread t;
    NewThread(){
        t = new Thread(this, "Demo Thread");
        System.out.println("Child thread :" + t);
        t.start();
    }
    @Override
    public void run() {
        try{
//子线程执行的代码
            for (int i=5 ; i>0; i++){
                System.out.println("Child Thread:"+ i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("Exiting child thred");
        }
    }
}


这个功能只是简单的实现了主线程和子线程互相交替打印字符串到控制台的功能，并且死循环的运行下去。
运行结果：
会不断互相交替打印"Child Thread i" 和 "Main Thtrad i",谁先谁后，不固定！
看了以上代码会发现一个疑惑的地方，线程的run()到底什么时间执行。
其实，线程运行start()方法后，线程被允许可以执行线程类中的run()方法。该方法不用我们调用，程序会自己执行。但是具体什么时间执行，主线程和子线程的执行的先后顺序，都是电脑cpu自动选择的结果。所以会出现交替打印的效果。


线程的结束？

一般我们都希望主线程比子线程晚结束。这样可以进行释放资源等操作！这里我们要用到join()方法！join()是等待一个线程终止。线程还有一个isAlive()方法，返回值为boolearn,判断该线程是否正在执行，是返回true，否返回false
看下面一个例子 
class NewMoreThread implements Runnable{
    Thread t;
    String name;
    NewMoreThread(String threadName){
        name = threadName;
        t = new Thread(this, name);
        System.out.println("New thread" + t);
        t.start();
    }
    @Override
    public void run() {
        try{
            for (int i=5 ; i>0; i--){
                System.out.println(name +":"+ i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println(name +"interruped.");
        }
        System.out.println(name + "exiting.");
    }
}
class JoinDemo{
    public static void main(String[] args){
        NewMoreThread ob1 =new NewMoreThread("One");
        NewMoreThread ob2 =new NewMoreThread("Two");
        NewMoreThread ob3 =new NewMoreThread("Three");
        System.out.println("Thread One os alive" + ob1.t.isAlive());
        System.out.println("Thread Two os alive" + ob2.t.isAlive());
        System.out.println("Thread Three os alive" + ob3.t.isAlive());
        try{
            System.out.println("Waiting for threads to finish.");
            ob1.t.join();
            ob2.t.join();
            ob3.t.join();
        } catch (Exception e){
            System.out.println("Main thread interruped.");
        }
        System.out.println("Thread One is alive:" + ob1.t.isAlive());
        System.out.println("Thread Two is alive:" + ob2.t.isAlive());
        System.out.println("Thread Three is alive:" + ob3.t.isAlive());
    }
}
打印结果：
New threadThread[Two,5,main]
New threadThread[Three,5,main]
One:5
Thread One os alivetrue
Two:5
Thread Two os alivetrue
Thread Three os alivetrue
Waiting for threads to finish.
Three:5
Three:4
One:4
Two:4
Two:3
Three:3
One:3
Three:2
One:2
Two:2
One:1
Three:1
Two:1
Disconnected from the target VM, address: '127.0.0.1:62114', transport: 'socket'
Twoexiting.
Threeexiting.
Oneexiting.
Thread One is alive:false
Thread Two is alive:false
Thread Three is alive:false
你会发现，三个线程都结束的时，才会执行最后的三个打印控制台操作！


线程的运行顺序？

很多人就想到，如果是多个线程一起运行，能不能手动控制运行的先后顺序。答案是不能绝对控制，线程的运行顺序和很多因素都有关系！只能提高某些线程获取cpu资源执行代码的几率!
线程通过；setPriority(Thread.MAX_PRIORITY);给线程赋予优先级。MAX_PRIORITY默认值是5.最大值是10，最小值是1，值越大，优先级越大。
先给大家一个例子！ 
class Clicker implements Runnable{
    int click = 0;
    Thread t;
    private volatile boolean running = true;
    public Clicker(int p){
        t = new Thread(this);
        t.setPriority(p);
    }
    @Override
    public void run() {
        while (running){
            click++;
        }
    }
    public void stop(){
        running = false;
    }
    public void start(){
        t.start();
    }
}
class HiLoPri{
    public static void main (String[] args){
        Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
        Clicker hi = new Clicker(Thread.NORM_PRIORITY + 2 );
        Clicker lo = new Clicker(Thread.NORM_PRIORITY - 2);
        hi.start();
        lo.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("Main thread interrupted.");
        }
        lo.stop();
        hi.stop();
        try {
            hi.t.join();
            lo.t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("InterrupetedException caught");
        }
        System.out.println("Low - priority thread:" +lo.click);
        System.out.println("High - priority thread:" +hi.click);
    }
}
运行结果：
High - priority thread:311376165
Low - priority thread:141875148
很明显，high的运行次数远大于low！因为执行的概率高！


当使用多线程时，同时操作一个对象时，可能出现重复操作的现象，造成输出结果混乱
线程同步 
class CallMe{
     void call(String msg){
        System.out.println("[" +msg);
        try{
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("Intrttupted");
        }
        System.out.println("]");
    }
}
class Caller implements Runnable{
    String msg;
    CallMe target;
    Thread t;
    public Caller(CallMe targ, String s){
        target = targ;
        msg = s;
        t = new Thread(this);
        t.start();
    }
    @Override
    public void run() {
        target.call(msg);
    }
}
class Synch {
    public static void main (String[] args){
        CallMe target = new CallMe();
        Caller ob1 = new Caller(target, "Hello");
        Caller ob2 = new Caller(target,"Synchronized");
        Caller ob3 = new Caller(target,"world");
        try{
            ob1.t.join();
            ob2.t.join();
            ob3.t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


运行结果会出现：
Hello[Synchronized{world]]]类似这种混乱的结果。此时，为了防止这种现象发生，我们希望每次只有一个线程在执行该方法，而其他线程不能进入这方法中。这时候，就要用synchronized关键字。用该关键字修饰的方法和类，一次只有一个线程可以使用或创建，
修改后的代码如下！ 
class CallMe{
    synchronized void call(String msg){
        System.out.println("[" +msg);
        try{
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("Intrttupted");
        }
        System.out.println("]");
    }
}
class Caller implements Runnable{
    String msg;
    CallMe target;
    Thread t;
    public Caller(CallMe targ, String s){
        target = targ;
        msg = s;
        t = new Thread(this);
        t.start();
    }
    @Override
    public void run() {
        target.call(msg);
    }
}
class Synch {
    public static void main (String[] args){
        CallMe target = new CallMe();
        Caller ob1 = new Caller(target, "Hello");
        Caller ob2 = new Caller(target,"Synchronized");
        Caller ob3 = new Caller(target,"world");
        try{
            ob1.t.join();
            ob2.t.join();
            ob3.t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程的通信

人门在设计线程通信的时候，总是希望生产者每生产一个资源，消费者就来消耗资源。线程的执行顺序是不可控的，假如生产者线程执行了5次，消费者线程才执行了一次，这种结果不是我们想要的，为了解决这种问题，我们要用到线程的另外三个方法！
wait() :挂起线程
notify() ：运行上一个被挂起的线程
notifyAll()：运行被挂起的所有线程
没有控制的代码： 
class Q {
    int n;
    synchronized  int get(){     
            System.out.println("Got:" +n);
            return n;
        }
    synchronized void put(int n){
        this.n = n;
        System.out.println("Put:" +n);
    }
}
class Producer implements Runnable{
    Q q;
    Producer(Q q ){
        this.q = q;
        new Thread(this, "Producer").start();
    }
    @Override
    public void run() {
        int i= 0;
        while(true){
            q.put(i++);
        }
    }
}
class Consumer implements Runnable{
    Q q ;
    Consumer(Q q){
        this.q = q;
        new Thread(this, "Consumer").start();
    }
    @Override
    public void run() {
        while(true){
            q.get();
        }
    }
}
class PC{
    public static void main(String[] args ){
        Q q = new Q();
        new Producer(q);
        new Consumer(q);
        System.out.println("Press Control -c to stop.");
    }
}
输出结果为:
Put:0
Put:1
Put:2
Put:3
Put:4
Put:5
Got:5
Put:6
Put:7
Put:8
Put:9
Put:10
Put:11
Put:12
Put:13
优化后的代码： 
class Q {
    int n;
    boolean valueSet = false;
    synchronized  int get(){
        if(!valueSet){
            try{
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Got:" +n);
            return n;
        }
        valueSet = false;
        notify();
        return n;
    }
    synchronized void put(int n){
        if (valueSet){
            try{
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.n = n;
        valueSet = true;
        System.out.println("Put:" +n);
        notify();
    }
}
class Producer implements Runnable{
    Q q;
    Producer(Q q ){
        this.q = q;
        new Thread(this, "Producer").start();
    }

    @Override
    public void run() {
        int i= 0;
        while(true){
            q.put(i++);
        }
    }
}
class Consumer implements Runnable{
    Q q ;
    Consumer(Q q){
        this.q = q;
        new Thread(this, "Consumer").start();
    }

    @Override
    public void run() {
        while(true){
            q.get();
        }
    }
}
class PC{
    public static void main(String[] args ){
        Q q = new Q();
        new Producer(q);
        new Consumer(q);
        System.out.println("Press Control -c to stop.");
    }
}
运行结果为：
Put:1
Got:1
Put:2
Got:2
Put:3
Got:3
Put:4
Got:4
Put:5
Got:5
Put:6
Got:6
Put:7
Got:7
Put:8
Got:8

实现人为控制的挂起进程:

class CommunicationThread implements  Runnable{
    String name;
    Thread t;
    boolean suspendFlag;
    CommunicationThread(String name){
        this.name = name;
        t =new Thread(this.name);
        System.out.println("New thread:" + t);
        suspendFlag = false;
        t.start();
    }
    @Override
    public void run() {
        try{
            for (int i= 0 ; i>0 ; i--){
                System.out.println(name +":"+i);
                Thread.sleep(1000);
                synchronized (this){
                    while (suspendFlag){
                        wait();
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name +"exiting.");
    }
    void mySuspend(){
        suspendFlag = true;
    }
    synchronized  void myResume(){
        suspendFlag = false;
        notify();
    }
}
class SuspendResume{
    public static void main(String[] args ){
        CommunicationThread ob1 =new CommunicationThread("One");
        CommunicationThread ob2 = new CommunicationThread("Two");
        try{
            Thread.sleep(1000);
            ob1.mySuspend();
            System.out.println("Suspending thread One");
            Thread.sleep(1000);
            ob1.myResume();
            System.out.println("Resuming thread One");
            Thread.sleep(1000);
            ob2.mySuspend();
            System.out.println("Suspending thread Two");
            Thread.sleep(1000);
            ob2.myResume();
            System.out.println("Resuming thread Two");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try{
            System.out.println("Waiting for threads to finish.");
            ob1.t.join();
            ob2.t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Main thread exiting.");
    }
}

第一次全面了解线程，哪里描述不当之处希望网友可以指出，让我学习更深入，在这里先谢过！！

努力的小码
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
freeRTOS。osThreadNew和LOS_TaskCreate的区别。
qq_31885403的博客
10-02 900
osThreadNew()是cmsis标准的接口，类似于posix标准的pthread_create()，它们是对具体内核的xOS_TaskCreate()接口的更上一层的封装，可以让上层应用（即osThreadNew()的调用者）与具体的内核解耦，有助于应用的一次开发，多端部署。LOS_TaskCreate()是LiteOS_A和LiteOS_M内核提供的创建线程的接口，LiteOS_A和LiteOS_M内核对它的实现是不同的，也就是说LOS_TaskCreate()跟具体的内核相关。
Binder机制
amin_hui的博客
07-30 634
Binder是Android系统提供的一种IPC机制，用于进程间通信 原理 IPC 　　每个Android的进程，只能运行在自己进程所拥有的虚拟地址空间。对应一个4GB的虚拟地址空间，其中3GB是用户空间，1GB是内核空间，当然内核空间的大小是可以通过参数配置调整的。 　　对于用户空间，不同进程之间彼此是不能共享的，而内核空间却是可共享的。 　　Client进程向Server进程通信，是利用进程间可共享的内核内存空间来完成底层通信工作 　　Client端与Server端进程往往采用ioctl等方法跟内核空
java输出线程时，显示Thread[main，5，main]，中括号里的三个值分别代表什么？
qq_37306041的博客
11-30 3251
1. 实例代码 public class SpinLockDemo { public static void main(String[] args) { Thread thread = Thread.currentThread(); System.out.println("当前线程名字："+ thread); } } 2.运行结果 3.说明 [线程名称, 线程优先级, 线程所属线程组] ...
osThreadNew函数详解
记忆蝴蝶
08-31 1969
设置任务的优先级，范围由0到(configMAX_PRIORITIES – 1)。包含了.name，.stack_size，.priority等属性，任务的句柄（handle），通过句柄可以对任务进行设置，任务的描述名称，方便调试，不用的话可以设为Null。比如改变任务优先级等，不用可以设为Null。用于传递给任务的参数，不用的话可以设为Null。用于传递给任务的参数，不用的话可以设为Null。这是一个函数指针，指向执行任务的函数。这是一个函数指针，指向执行任务的函数。每个任务有自己的栈空间，.......
STM32 FreeRTOS CMSIS—OS
YuHWEI的博客
01-08 3469
使用STM32CubeMX代码生成，在 STM32Cube 固件中，通过 ARM 提供的通用 CMSIS-OS 封装层，将 FreeRTOS 用作实时操作系统。也就是说在一套代码里有着两套标准，在阅读源码时需要注意区分。
C#语言多线程初步理解
12-03
通过控件启动，暂停，继续等按钮，操作子线程，在winform控件中输出数据。对于初学者来说可以根据代码很快理解多线程，对多线程的认识
Ruby多线程编程初步入门
01-21
Ruby的可以使用 Thread 类很容易地编写多线程程序。 Ruby线程是一个轻量级的和高效的在代码中实现并行性。 创建Ruby线程： 要启动一个新线程，关联一个块通过调用Thread.new。将创建一个新的线程执行的代码块，原始...
初步了解线程
03-20
初步了解线程 和画布的使用 对线程初学者有大用
初步讲解Ruby编程中的多线程
01-02
每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。 线程是程序中一个单一的顺序控制流程，在单个程序中同时运行多个...以下实例展示了如何在Ruby程序中使用多线程： #!/usr/bin/ruby def func1 i=
基于单线程贪吃蛇游戏的初步尝试.cpp
04-14
wasd操作，英文输入法，单线程，比较笨重的东西，内存量尽管要求不大，不过浪费了很多资源，没有进行进一步的优化，有问题私信联系
CMSIS_OS API介绍
07-09
CMSIS_OS API介绍，功能简介，使用实例
鸿蒙Hi3861学习十一-Huawei LiteOS-M（内存池）
qq_26226375的博客
05-11 1311
创建内存池。不能在中断中调用。block_count：申请的内存块个数block_size：每个内存块的大小attr：属性。自定义内存时使用，默认为NULLNULL：失败其他值：内存池ID。
HI3861学习笔记（5）——LiteOS(CMSIS-RTOS2)任务管理
Leung的博客
06-06 1518
一、简介 从系统的角度看，任务是竞争系统资源的最小运行单元。任务可以使用或等待CPU、使用内存空间等系统资源，并独立于其它任务运行。 LiteOS的任务模块可以给用户提供多个任务，实现了任务之间的切换和通信，帮助用户管理业务程序流程。这样用户可以将更多的精力投入到业务功能的实现中。 LiteOS中的任务是抢占式调度机制，高优先级的任务可打断低优先级任务，低优先级任务必须在高优先级任务阻塞或结束后才能得到调度，同时支持时间片轮转调度方式。 LiteOS的任务默认有32个优先级(0-31)，最高优先级为0，
鸿蒙Hi3861学习五-Huawei LiteOS-M（任务管理）
qq_26226375的博客
05-05 1607
任务ID：在任务创建时通过参数返回给用户，作为任务的一个非常重要的标识任务优先级：优先级标识任务执行的优先顺序任务入口函数：每个新任务得到调度后将执行的函数任务控制块TCB：每个任务都含有一个任务控制快（TCB-Task Control Block）。TCB包含了任务上下文栈指针（stack pointer）、任务状态、任务优先级、任务ID、任务名、任务栈大小等信息。TCB可以反映出每个任务的运行情况。任务栈：每个任务都拥有一个独立的栈空间，称为任务栈。任务上下文：任务在运行过程中使用到的一些资源。
【翻译CMSIS_RTOS2 API v2】鸿蒙CMSIS-RTOS2接口之任务（线程）管理
hjh_cos
01-25 1365
RTOS2中文接口
stm32RTOS创建任务
m0_49476241的博客
02-21 1215
文章目录前言一、cuebMX配置二、代码解析总结 前言 本篇文章带大家学习一下如何使用RTOS API函数创建任务。 一、cuebMX配置 具体配置 二、代码解析 osThreadId defaultTaskHandle; osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 128); defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL); void St
Niobe开发板：基于OpenHarmony操作系统进行多线程(多任务)开发
m0_64688415的博客
05-20 822
线程的基本概念 从系统角度看，线程是竞争系统资源的最小运行单元。线程可以使用或等待CPU、使用内存空间等系统资源，并独立于其它线程运行。 OpenHarmony LiteOS可以给用户提供多个线程，实现线程间的切换，帮助用户管理业务程序流程。具有如下特性： 支持多线程。 一个线程代表一个任务 抢占式调度机制，高优先级的线程可打断低优先级线程，低优先级线程必须在高优先级线程阻塞或结束后才能得到调度。 相同优先级线程支持时间片轮转调度方式。 共有32个优先级[0-31]，最高优先级为0，最低优先级
解决 Disconnected from the target VM, address: ‘127.0.0.1:51458‘, transport: ‘socket‘
热门推荐
五行缺火
08-31 21万+
debug启动Spring boot项目的时候，项目没有启动起来。log最后一行，显示Disconnected from the target VM, address: '127.0.0.1:51458', transport: 'socket'。 看到这，第一个感觉就是端口被占用了。 解决端口占用问题，首先查看端口的启动情况 win+R 输入cmd打开DOS命令框。输入：netstat -ano | findstr 8060 其中8060是我服务的端口号。 显示这种，说明后台8060端口还在.
项目启动时报错：Disconnected from the target VM, address: ‘127.0.0.1:XXX‘, transport: ‘socket‘解决方案
ITliuht的博客
05-31 7万+
项目启动时报错：Disconnected from the target VM, address: ‘127.0.0.1:XXX‘, transport: ‘socket‘解决方案 场景：出现这个报错有可能是IDEA非正常关闭，导致端口还在占用着。比如我在安装JRebel插件时，安装完成后点击了重启IDEA，再跑项目的时候就开始报错了。 解决方案： 1.打开CMD，输入 netstat -nao | findstr (项目后端端口，我的是7777) 发现7777端口还在运行，PID 为15600的进程也在
初步认识ThreadLocal
最新发布
09-13
ThreadLocal是Java中的一个类，用于在多线程环境下为每个线程提供独立的变量副本。每个线程内部都有一个ThreadLocal....这样，不同线程可以独立地使用ThreadLocal对象，并且互不干扰，保证了线程安全性和数据隔离性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值