线程

最新推荐文章于 2024-11-04 20:33:37 发布
置顶 最新推荐文章于 2024-11-04 20:33:37 发布
阅读量306 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yellow_biu/article/details/101344538
版权

线程

1.进程概述

进程简单来说就是计算机运行的一个程序

2.线程概述

线程是进程运行的最小单元，或者说是线程是进程的一条执行路径。一个进程至少包含一个线程，如果一个进程包含多个线程，则称为多线程应用程序。例如百度云，可同时下载多个内容。
主线程：jvm运行程序会创建一个main线程（主线程），该线程负责执行main方法。
子线程：线程并不是孤立的，而是相互联系。假设在A线程中创建了B线程, 习惯上称A线程为父线程, 称B线程为子线程。
串行：

在这里插入图片描述

并发：

在这里插入图片描述

并行：

在这里插入图片描述

3创建线程
3.1创建线程的两种方法
1）一个是定义Thread类的子类
package Threadnew;

/**
 * Author:wenyu
 * 2019/9/25
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建线程
        Thread t1 = new subThread();
        //启动线程
        t1.start();
    }
}
class subThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("这是子线程执行的代码："+i);
        }
    }
}
2）一个定义Runnable接口的实现类
package Threadnew;

/**
 * Author:wenyu
 * 2019/9/25
 */
public class Demo02 {
    public static void main(String[] args) {
        //3）定义Runnable接口的实现类对象
        Prime p =new Prime();
        //4）创建线程，调用Thread(Runable)构造方法
        Thread thread = new Thread(p);
        //5）开启新的线程
        thread.start();
    }

}
//1)定义Runnable接口的实现类
class Prime implements Runnable{
    //2)重写接口的run()方法
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println("这是子线程执行的程序："+i);
        }

    }
}
3）其他创建线程的方式
package Threadnew;

/**
 * Author:wenyu
 * 2019/9/25
 */
public class Demo03 {
    public static void main(String[] args) {
        //Thread类实现了Runnable接口,SubThread继承了Thread类,SubThread也是Runnable接口的实现类
        subThread thread  =new subThread();
        Thread t3 = new Thread(thread);
        t3.start();

        //
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("这是匿名内部类中的内容:"+i);
                }
            }
        });
        t4.start();

        new subThread().start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("另外一个子线程："+i);
                }
            }
        }).start();

    }
}
4线程的常用方法

currentThread() 返回当前线程
getName() 返回线程名称
isAlive() 判断线程是否处于活动状态
sleep() 线程休眠
interrupt() 中断线程 只是打了一个中断标志，不是真正的终止线程
yield() 放弃当前线程的cpu执行权 有可能刚放弃就重新获得
getPriority() 线程优先级 1-10 默认优先级是5 一般不做修改
setDaeman 守护线程 守护线程不能独立运行. 典型的守护线程就是垃圾回收线程

currentThread() setName() getName()
package Threadnew;

/**
 * Author:wenyu
 * 2019/9/25
 */
public class Demo04 {
    public static void main(String[] args) {
        subThread04 t1 = new subThread04();
        Thread thread = new Thread(t1);
        thread.setName("t1");
        thread.start();
    }
}
class subThread04 implements Runnable{
    public subThread04(){
        System.out.println("构造方法中打印当前线程："+Thread.currentThread().getName());
    }
    @Override
    public void run() {
        System.out.println("run方法中打印当前线程："+Thread.currentThread().getName());
    }
}
isAlive()
package Threadnew;

/**
 * Author:wenyu
 * 2019/9/25
 */
public class Demo05 {
    public static void main(String[] args) {
        subThread subThread  = new subThread();
        System.out.println("before:"+subThread.isAlive());
        subThread.start();
        System.out.println("after:"+subThread.isAlive());
    }
    //使用静态内部类定义一个Thread线程类的子类,只在当前Demo05类的main方法中使用
    static class subThread extends Thread{
        @Override
        public void run() {
            System.out.println("run ="+this.isAlive());
        }
    }
}
sleep()
package Threadnew;

/**
 * Author:wenyu
 * 2019/9/25
 */
public class Demo06 {
    public static void main(String[] args) {
        subThread t1 = new subThread();
        System.out.println(Thread.currentThread().getName()+": before: "+System.currentTimeMillis());
        t1.start();
        System.out.println(Thread.currentThread().getName()+": after: "+System.currentTimeMillis());

    }
    static class subThread extends Thread{
        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName()+": before:"+System.currentTimeMillis());
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + ": after:" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
interrupt()

Java中有三种方式可以终止线程的执行:

  1. 使用退出标志,使线程正常退出, 想办法让run()运行结束
  2. 使用stop()强行终止,不建议使用
  3. 使用interrupt()中断线程, 仅仅在是当前线程中打了一个中断标志,并不是真正的终止线程.
package Threadnew;

/**
 * Author:wenyu
 * 2019/9/25
 */
public class Demo07 {
    public static void main(String[] args) {

            SubThread t = new SubThread();
            t.start();

            //main线程打印100行
            for (int i = 0; i < 100; i++) {
                System.out.println("main: " + i);
            }
            //中断子线程
            t.interrupt();
            //仅仅是给线程 加一个中断标志, 并没有终止线程
            System.out.println(t.isInterrupted());      //true
        }
        static  class SubThread extends Thread{
            @Override
            public void run() {
                super.run();
                for (int i = 0; i < 1000; i++) {
                    System.out.println("sub thread --> " + i);

                }
            }
        }
}

在子线程中通过判断中断标志来结束线程

package Threadnew;

/**
 * 子线程通过中断标志来退出程序
 * Author:wenyu
 * 2019/9/25
 */
public class Demo08 {
    public static void main(String[] args) {
        subThread t1 = new subThread();
        t1.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+i);
        }
        t1.interrupt();//中断子线程
        System.out.println(t1.isInterrupted());
    }
    static class subThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                if(this.isInterrupted()){
                    System.out.println("当前程序线程被终止");
                   // break;
                    return;
                }
                System.out.println("subThread->"+i);
            }
            System.out.println("这是for循环之后的代码");
        }
    }
}

通过修改标志来结束线程

package Threadnew;

/**
 * Author:wenyu
 * 2019/9/25
 */
public class Demo09 {
    public static void main(String[] args) {
        subThread s1 = new subThread();
        Thread t1 = new Thread(s1);
        t1.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+i);
        }
        //把子线程结束
        s1.running=false;
    }
    static class subThread implements Runnable{
        public boolean running = true; //线程运行标志
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                //检查线程状态
                if (!running){
                    break;
                }
                System.out.println("subThread->"+i);
            }
            System.out.println("这是子线程中for循环之后的代码");
        }
    }
}
getPriority()
package Threadnew;

/**
 * Author:wenyu
 * 2019/9/25
 */
public class Demo10 {
    public static void main(String[] args) {
        subThread t1 = new subThread();
        t1.setName("t1");
        //设置线程优先级
        t1.setPriority(1);
        t1.start();
        subThread t2 = new subThread();
        t2.setName("t2");
        //设置线程优先级
        t2.setPriority(10);
        t2.start();
    }
    static class subThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
getDeamon()
package Threadnew;

/**
 * Author:wenyu
 * 2019/9/25
 */
public class Demo11 {
    public static void main(String[] args) {
        subThread1 t1 = new subThread1();
        t1.setName("t1");
        t1.setDaemon(true);//将t1设为守护线程
        t1.start();

        subThread2 t2 = new subThread2();
        t2.setName("t2");
        t2.start();
        //当t2线程执行完毕, JVM只有t1线程时,JVM会退出
    }
    static class subThread1 extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
    static class subThread2 extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
查看线程状态 getState()
ackage Threadnew;

/**
 * Author:wenyu
 * 2019/9/25
 */
public class Demo12 {
    public static void main(String[] args) throws InterruptedException {
        subThread t1 = new subThread();
        t1.setName("t1");
        System.out.println(t1.getState());//NEW
        t1.start();
        System.out.println(t1.getState());//RUNNABLE
        Thread.sleep(200);
        System.out.println(t1.getState());//TERMINATED
        Thread.sleep(1000);
        System.out.println(t1.getState());//TERMINATED

    }
    static class subThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(this.getName()+":"+i);
            }
        }
    }
}
5线程同步

线程同步机制是一种用于协调线程之间数据访问的机制.
Java平台的线程同步机制包括锁, volatile关键字, 相关的方法.Object类中wait()/notify()

1）同步代码块
package Threadnew;

/**
 * Author:wenyu
 * 2019/9/25
 */
public class Demo13 {
    static  int num = 100;        //定义静态变量,作为共享数据
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new subThread().start();
        }
    }
    static class subThread extends Thread{
        static final Object obj = new Object();
        @Override
        public void run() {
            while (true){
            //同步代码块同步实例方法
                synchronized (obj) {
                    while (num>0){
                        System.out.println(Thread.currentThread().getName()+"--"+num--);
                    }
                }
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
				break;
            }
        }
    }
}
2）同步方法

直接使用synchronized修饰方法
如果修饰实例方法就是同步实例方法
如果修饰静态方法,就是同步静态方法

package Threadnew;

/**
 * Author:wenyu
 * 2019/9/26
 */
public class Demo14 {
    public static void main(String[] args) {
        Demo14 obj = new Demo14();
        //开启两个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                Demo14.print();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                Demo14.print2();
            }
        }).start();
    }

    public static void print(){
        synchronized (Demo14.class) {//当前类的字节码作为锁对象
            for (int i = 0; i < 50; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
    //同步静态方法, 使用当前类的运行时类对象,即类的字节码Test08.class作为锁对象
    public synchronized static void print2(){
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
6.死锁

在多线程中，如果需要获取多个锁对象，如果获取锁对象的顺序不一样，可能造成相互等待的情况，被称为死锁。

7.volatile

volatile关键字的作用就是让变量在多个线程之间可见

package Threadnew;

/**
 * Author:wenyu
 * 2019/9/26
 */
public class Demo15 {
    public static void main(String[] args) throws InterruptedException {
        PrintString obj = new PrintString();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    obj.printStringMethod();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        //Thread.sleep(100);

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
        //修改main线程中的continuePrint
        obj.setContinuePrint(false);
    }
    //定义打印字符串的类
    static class PrintString{
        //定义打印标志
        private volatile Boolean continuePrint = true;

        public PrintString setContinuePrint(Boolean continuePrint){
            this.continuePrint=continuePrint;
            return this;
        }

        public void printStringMethod() throws InterruptedException {
            System.out.println("开始打印。。。");
            while (continuePrint){
                for (int i = 0; i < 10000; i++) {
                    if(continuePrint==true){
                        //Thread.sleep(10);
                        System.out.println(i);
                    }else {
                        break;
                    }
                }
            }
            System.out.println("结束打印");
        }
    }
}
花事了丶
关注
多线程(一)：创建线程和线程的常用方法
人不风流枉少年
09-01 24万+
一：为什么要学多线程 应付面试 ：多线程几乎是面试中必问的题，所以掌握一定的基础知识是必须的。 了解并发编程：实际工作中很少写多线程的代码，这部分代码一般都被人封装起来了，在业务中使用多线程的机会也不是很多(看具体项目)，但是作为一个高级程序员如果不会多线程是说不过去的。 二：进程与线程 进程 进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统...
线程与同步
小生不才的博客
11-13 3069
1.Thread的常用方法和总结 1.1.通过getName()获取当前线程的名称 要获取当前线程的名称，首先要获取当前线程对象: 在MyThread类(继承Thread的方式)中获取当前线程对象比较简单，直接在run方法中通过this就可以 因为MyThread类就是线程类，创建的MyThread对象就是线程对象，而this表示当前对象，因此当通过MyThread对象调用run方法时，run方法中的this表示调用该方法的对象，也就是当前线程对象 在MyThread类中获取当前线程对象以及输出线程名称如
【多线程与高并发】- 浅谈volatile
qq_43843951的博客
02-24 22万+
volatile是Java语言中的一种轻量级的同步机制，它可以确保共享变量的内存可见性，也就是当一个线程修改了共享变量的值时，其他线程能够立即知道这个修改。
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
CountDownLatch实战应用——实现异步多线程业务处理，异常情况回滚全部子线程
一恍过去
12-17 1万+
CountDownLatch实战应用——实现异步多线程业务处理，异常情况回滚全部子线程
Python多线程详解
ifhuke的博客
03-10 2万+
关于Python多线程的详细解读
多线程——线程的退出
glory的博客
09-24 4179
一般来说，一个线程的退出，有多种方式： 1.return方式/exit/_exit 2.利用pthread_exit退出 3.利用phread_cancel 退出以下几种方式均可以让线程退出，但是相互间也是有区别的，下面通过实例来演示。 pthread_exit函数用于实现线程退出 头文件#include<pthread.h> 函数原型void pthread_exit(void *retval); 无返回值 参数列表 void *retval：返回的参数NULL ...
C语言多线程
微小冷的学习笔记
03-19 9059
在C语言中创建线程方式如下 #include <pthread.h> pthread_create (thread, attr, start_routine, arg) 其中，thread为线程指针；attr为线程属性，默认NULL；start_routine为线程运行函数起始地址；arg为运行函数的参数。无参数时使用NULL。 如果线程成功创建，函数返回0，否则说明创建失败。 当线程完成工作后，若无需继续存在，则会调用pthread_exit函数。也就是说，这个函数可以显式地退出一个线程。
全面详解Android实现多线程的几种方式（史上最全，最详细）
恬静释然的博客
11-19 4万+
一、目录 Android多线程实现方式包括： 二、基础使用 Android多线程实现的基础使用包括： 继承Thread类 实现Runnable接口 Handler 接下来对各个进行分析。 1、继承Thread类 1.1 简介 1.2 使用详解 （1）使用步骤 （2） 具体使用 // 步骤1：创建线程类 （继承自Thread类） class MyThread extends Thr...
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 416
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 930
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 971
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 974
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 486
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 332
默认对常规Session的理解和使用，如何使用Set-Cookie。
Java线程优先级详解
"Java线程的优先级管理是多线程编程中的一个重要概念，它涉及到线程调度和执行的顺序。在Java中，线程的优先级被用来影响线程被操作系统选择执行的概率，但并不保证高优先级的线程一定会先于低优先级的线程执行。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值