Java 多线程编程

最新推荐文章于 2023-07-30 18:54:37 发布
最新推荐文章于 2023-07-30 18:54:37 发布
阅读量893 收藏 3
点赞数
分类专栏： Java基础 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lx00000025/article/details/131059915
版权

目录

一、简介

Java多线程是指一个进程在执行过程中可以产生多个更小的程序单元，这些更小的单元称为线程，这些线程可以同时存在，同时运行，一个进程可能包含多个同时执行的线程。多线程是实现并发机制的一种有效手段。在 Java中实现多线程有两种手段，一种是继承Thread类，另一种就是实现Runnable接口。

线程是进程内部比进程更小的执行单元(执行流|程序片段),每个线程完成一个任务,每个进程内部包含了多个线程每个线程做自己的事情，在进程中的所有线程共享该进程的资源。

二、线程的生命周期

在这里插入图片描述

  • 新建状态:
    使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

  • 就绪状态:
    当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

  • 运行状态:
    如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

  • 阻塞状态:
    如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

    • 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

    • 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

    • 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

    • 死亡状态:
      一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

三、Thread 方法

方法作用
start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
run()如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
setName(String name)改变线程名称，使之与参数 name 相同。
setPriority(int priority)更改线程的优先级。
setDaemon(boolean on)将该线程标记为守护线程或用户线程。
join(long millisec)等待该线程终止的时间最长为 millis 毫秒。
interrupt()中断线程。
isAlive()测试线程是否处于活动状态。

上述方法是被 Thread 对象调用的，下面表格的方法是 Thread 类的静态方法。

静态方法作用
yield()暂停当前正在执行的线程对象，并执行其他线程。
sleep(long millisec)在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
holdsLock(Object x)当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。
currentThread()返回对当前正在执行的线程对象的引用。
dumpStack()将当前线程的堆栈跟踪打印至标准错误流。

静态方法比较常用的就是currentThread、sleep、yield

四、创建线程

1.通过继承Thread类

public class Demo1_thread {
    public static void main(String[] args) {
        Mythread mt = new Mythread();
        mt.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("bbbbbbbbbbbbbbbb");
        }
    }
}
class Mythread extends Thread{//继承Thread
    @Override
    public void run() {//重写run方法
        for (int i = 0; i < 1000; i++) {//将要执行的代码写在run方法中
            System.out.println("aaaaaaaaaaa");
        }
    }
}

上面代码需要重写run方法，在创建线程之后通过start()方法来调用线程。

2.通过实现Runnable接口

public class Demo2_thread {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();//创建子类对象
        Thread tr = new Thread(mr);
        tr.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("bbbbbbbb");
        }
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("aaaaaaaaa");
        }
    }
}

和第一种很类似，也是要重写run方法，重要的是理解的 run() 可以调用其他方法，使用其他类，并声明变量，就像主线程一样。

3.匿名内部类创建线程

//匿名内部类
public class Demo3_thread {
    public static void main(String[] args) {
        new Thread("hhhh"){//继承thread类,name代表线程的名称
            @Override
            public void run() {//重写run方法
                for (int i = 0; i < 1000; i++) {
                    System.out.println(this.getName()+"aaaaaaaaaaaaa");
                }
            }
        }.start();
        Thread.currentThread().setName("我是主线程");
        System.out.println(Thread.currentThread().getName());
        for (int i = 0; i < 1000; i++) {
            System.out.println("bbbbbbbbbbbbbb");
        }
        new Thread(new Runnable() {//将runnable的子类对象传递给Thread的构造方法
            @Override
            public void run() {//重写run方法
                for (int i = 0; i < 1000; i++) {//Thread.currentThread()获取当前线程对象
                    System.out.println(Thread.currentThread().getName()+"acccccccccccccca");
                }
            }
        }).start();
    }
}

五、线程方法应用

5.1、sleep()

public class Demo4_threadSleep {
    public static void main(String[] args) throws InterruptedException {
        new Thread(){
            @Override
            public void run(){
                for (int i = 0; i < 20; i++) {
                    try {
                        Thread.sleep(1000);//单位毫秒
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(getName()+i);
                }
            }
        }.start();
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 20; i++) {
            Thread.sleep(1000);//单位毫秒
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

run（）方法中的异常只能try catch，因为父类没有抛出异常，子类不能抛出比父类更多的异常。

5.2、setDaemon()

特点：守护线程，等别的线程结束自己自动退出
其它的和普通线程没有什么区别， 一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。

//守护线程，等别的线程结束自己自动退出
public class Demo5_Daemon {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 2; i++) {
                    System.out.println(getName()+"aaaaaaaa");
                }
            }
        };
        Thread t2 = new Thread("守护线程"){
            @Override
            public void run() {
                while (true){
                    System.out.println(getName()+"bbbbbbbbbbbbbbb");
                }
            }
        };
        t2.setDaemon(true);//开启守护线程
        t1.start();
        t2.start();
    }
}

5.3、interrupt()方法和stop()方法

public class Demo12_interrupt {
    public static void main(String[] args) {
        Mytd t = new Mytd();
        t.setName("t");
        t.start();
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //终断t线程的睡眠（这种终断睡眠的方式依靠了java的异常处理机制。）
        t.interrupt();
        //t.stop(); //强行终止线程
        //缺点:容易损坏数据  线程没有保存的数据容易丢失
    }
}
class Mytd extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行");
        try {
            Thread.sleep(1000 * 60 * 60 * 24 * 365);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName()+"结束执行");
    }
}

5.4、yield()

暂停当前正在执行的线程对象，并执行其他线程
yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
注意：在回到就绪之后，有可能还会再次抢到。

public class Demo13_yield {
    public static void main(String[] args) {
        MyThread t1 = new MyThread("线程1");
        MyThread t2 = new MyThread("线程2");
        MyThread t3 = new MyThread("线程3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyThread extends Thread{
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            if(i==30){
                //当循i环到30时，让线程让步
                Thread.yield();
                //1、回到抢占队列中，又争夺到了执行权
                //2、回到抢占队列中，没有争夺到执行权
            }
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

5.5、join()

这个方法的作用是先将当前线程挂起，待其他线程结束后在执行当前线程的代码；
在这里插入图片描述

//加入线程，等待指定线程结束后在执行
public class Demo6_join {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(getName()+"aaaaaaaa");
                }
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    if (i == 2) {
                        try{
                            t1.join(1);//插队1毫秒
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }
                    System.out.println(getName()+"bbbbbbbbbbbbbbb");
                }
            }
        };
        t1.start();
        t2.start();

    }
}

5.6、线程优先级

  • getPriority():获取线程优先级
  • setPriority：设置线程优先级
public class Demo14_Priority {
    public static void main(String[] args) {
        MyThread2  t1 = new MyThread2("线程1");
        MyThread2  t2 = new MyThread2("线程2");
        MyThread2  t3 = new MyThread2("线程3");
        //默认等级是5
        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());
        System.out.println(t3.getPriority());
        System.out.println(Thread.MAX_PRIORITY);//10
        System.out.println(Thread.NORM_PRIORITY);//5
        System.out.println(Thread.MIN_PRIORITY);//1
        //设置t1线程的优先级为6
        t1.setPriority(6);
        System.out.println(t1.getPriority());
    }
}

5.7、synchronized锁

  • 一把锁只能同时被一个线程获取，没有获得锁的线程只能阻塞等待
  • synchronized修饰的方法，无论方法正常执行完毕还是抛出异常，都会释放锁
    每个实例都对应有自己的一把锁(this),不同实例之间互不影响；例如锁对象是*.class以及synchronized修饰的是static方法的时候，所有对象公用同一把锁
/*
* 同步代码块
*有多段代码执行时希望一段代码执行的过程中cpu不要切换到其他线程工作，所以就加同步
* */
public class Demo7_Synchronized {
    public static void main(String[] args) {
        final Printer p1 = new Printer();
        new Thread(){
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(getName());
                    p1.print1();
                }
            }
        }.start();
        new Thread(){
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(getName());
                    p1.print2();
                }
            }
        }.start();
    }
}
class Printer {
    Demo d = new Demo();
    public void print1() {
        synchronized (d) {//同步 代码块锁对象,锁对象可以是任意的，随便创建一个对象都可以，不可以匿名内部类
            System.out.print("h1");
            System.out.print("h2");
            System.out.print("h3");
            System.out.print("h4");
            System.out.print("h5");
            System.out.print("\r\n");
        }
    }

    public void print2() {
        synchronized (d) {
            System.out.print("h6");
            System.out.print("h7");
            System.out.print("h8");
            System.out.print("h9");
            System.out.print("\r\n");
        }
    }
}
class Demo{

}

应用场景：例如火车卖票，多人抢票的时候就会出现数据安全问题，比如现在只有100张票，每个人在抢的时候肯定要遵守先到先得的原则，当一个人开始抢的时候就给他分配一把锁，然后用完之后释放这把锁给下一个人，有锁的人才能进行抢票，这样就解决了并发的问题。

//火车卖票
public class Demo8_Synchronized {
    public static void main(String[] args) {
        MyTicket mt = new MyTicket();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}
class MyTicket implements Runnable{
    private int ticket = 100;
    public void run() {
        while (true){
            synchronized (MyTicket.class) {
                if (ticket == 0) {
                    break;
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "这是第" + ticket-- + "号票");
            }
        }
    }
}

5.8、定时器

定时器的作用：
间隔特定的时间，执行特定的程序。

public class Demo11_Timer {
    public static void main(String[] args) throws InterruptedException {
        Timer t = new Timer();
        t.schedule(new MyTimer(),new Date(122,9,7,13,37,30),3000);//每过三秒执行一次
        while (true){
            Thread.sleep(1000);
            System.out.println(new Date());
            System.gc();//将编程垃圾的定时器进行回收
        }
    }
}
class MyTimer extends TimerTask{
    @Override
    public void run() {
        System.out.println("起床吃饭");
    }
}
蓝朽
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JAVA线程学习(源代码)
10-28
附带JAVA线程源代码，从代码中分析和学习java线程。
编程必备：JAVA多线程详解
拾一二的博客
06-14 6699
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
【Java 基础篇】Java多线程编程详解
繁依Fanyi的博客
06-26 1965
本文详细介绍了Java多线程编程的概念、原理和常用技术。多线程编程可以提高程序的性能和响应能力，但也需要注意线程安全和线程同步的问题。在实际开发中，合理地使用多线程可以充分发挥多核处理器的优势，提高程序的并发能力和执行效率。同时，需要注意避免多线程之间的竞争条件和数据一致性问题，保证线程的安全性和正确性。希望本文对你理解和应用Java多线程编程有所帮助！
同步异步阻塞和非阻塞的区别理解
钟灵毓秀的博客
08-28 765
一、同步和异步 同步和异步是一种 消息通知机制 同步：发出一次请求后必须等到该请求有返回结果，才能继续下一步工作；请求者需主动询问是否有返回结果； 异步：发出一次请求后无需等到该请求有返回结果，即可进行下一步工作；请求有结果后，会以某种方式通知请求者； 同步和异步是相对于操作结果来说，会不会等待结果返回 异步一般通过状态、通知和回调来通知调用者。 状态：即监听被调用者的状态（轮询），调用者需...
java-多线程编程
weixin_53700016的博客
04-18 2203
1、基本概念 程序：是为了完成某特定任务，用某语言编写的一组指令的集合。 进程：是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位。 线程：是进程中的一个实体，作为系统调度和分派的基本单位。 一个java程序的正常运行，至少需要三个线程。（main主线程、gc垃圾回收线程、议程处理线程） 并行：多个CPU同时执行多个任务。 并发：一个CPU采用时间片的方法同时执行多个任务 2、线程的状态 新建（New）：在程序中用构造方法创建一个线程对象后，新的线程对象便
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
Java多线程编程
05-02
包括java的Thread类，同步块(synchronized)，可重入锁，Object方法以及对象监视器等内容。
JAVA多线程编程技术PDF
08-28
JAVA多线程编程技术PDF，是最经典的那个版本，多线程的所有知识点完爆读者
Java多线程编程实战指南(核心篇)
07-17
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了――如今...
Java 多线程编程基础(详细)
热门推荐
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
多线程编程
yahid的博客
07-24 2562
多线程指的是一个程序中包含两个或者两个以上的线程，多线程的提出是为提高代码的执行效率，这就好比工厂中的流水线，只有一条称为单线程，有多条流水线就成为多线程。多线程提高效率的同时由于并发执行的不确定性，导致出现的结果很多是我们不想要的，所以为了得到我们想要的结果就会在编写多线程的时候加入各种锁，其中最重要的就是synchronized和volatile。在认识它们之前现从多线程最基本的开始。...............
JAVA高级编程之多线程（看完这一篇就够了）
qq_53821298的博客
03-15 565
1、计算机中，按照冯诺依曼体系把计算机硬件分为了5部分，分别对应：存储器、运算器、控制器、输入设备、输出设备；而运算器和控制器就组成了CPU、中文名叫中央处理单元；2、我们一个程序要想执行，第一步就得把它从磁盘或者其他外存上移到内存中去，这一步操作系统帮我们做了；当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的。
Java多线程编程【一文全解】
Lov1_BYS的博客
11-27 1121
Java多线程从0到1全讲解
java创建多线程的7种方式---代码详解
初夏0811的博客
07-30 1万+
可以看出，主线程是不需要等待子线程执行完再执行下面的程序，主线程执行完了子线程还在执行，因此，子线程报错是不会影响主线程的。callable和future现成可以获取到返回的结果，底层是基于LockSupport,从JDK5就提供了Callable接口，该接口是Runable的增强版。
【线程】多线程编程
qq_53830608的博客
11-17 2709
概念 线程是程序中完成一个独立任务的完整执行序列，即一个可调度的实体。 根据运行环境和调度者的身份，县城可分为内核线程和用户线程。 线程运行在内核空间，由内核来调度。 当进程的一个内核线程获得CPU的使用权时，他就加载并执行一个用户线程 线程库负责管理所有执行线程，比如线程的优先级、时间片等。线程库利用longjmp来切换线程的执行，使他们看起来像”并发“执行，但实际内核仍然是把整个进程作为最小单位来调度。 一个进程的所有执行线程共享该进程的时间片，他们对外表现出相同优先级。 线程的实现方式分为三种模式：完
Java高级编程——多线程
qq_61524266的博客
05-16 463
目录Java高级编程之多线程一、基本概念：程序、进程、线程1.基本概念2.使用多线程的优点 3.何时需要多线程 二、线程的创建和使用1.线程的创建和启动 2.Thread类 3.API中创建线程的两种方式 代码演示代码演示 4.线程的调度三、线程的生命周期1.JDK中用Thread.State类定义了线程的几种状态四、线程的同步1.问题的提出 2.Synchronized的使用方法 3.代码演示使用同步代码解决实现Runnable接口的线程安全问题使用同步代码解决实现继承的线程安全问题使用同步方法解决实现
java 多线程编程pdf
最新发布
12-16
Java多线程编程PDF是一本介绍Java多线程编程的PDF文档，其中包含了Java多线程编程的基本概念、原理、技术和实践经验。该PDF文档可以帮助读者快速了解Java多线程编程的相关知识，并提供实用的编程示例和案例分析，有...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

蓝朽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值