Java多线程

最新推荐文章于 2024-04-19 21:50:42 发布
最新推荐文章于 2024-04-19 21:50:42 发布
阅读量592 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java&Javaweb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/umgsai/article/details/38467795

1.简单Java多线程例子（继承Thread）

public class hello extends Thread{
    private String name;
                                                                                                                                                                                                                                                                                                                                                       
    public hello(String name) {
        this.name = name;
    }
                                                                                                                                                                                                                                                                                                                                                       
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "运行..." + i);
        }
    }
                                                                                                                                                                                                                                                                                                                                                       
    public static void main(String[] args) {
        hello hello1 = new hello("A");
        hello hello2 = new hello("B");
        hello hello3 = new hello("C");
        hello1.start();
        hello2.start();
        hello3.start();
    }
}

某一次的执行结果为：

B运行...0

B运行...1

B运行...2

C运行...0

A运行...0

C运行...1

B运行...3

C运行...2

A运行...1

C运行...3

B运行...4

C运行...4

A运行...2

A运行...3

A运行...4


2.简单Java多线程例子（实现Runnable接口）

public class Test1 implements Runnable {//实现Runnable接口
    private String name;
    public Test1(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "运行..." + i);
        }
    }
                                                                                                                                                                                                                                                                                                                                    
    public static void main(String[] args) {
        Test1 test1 = new Test1("线程A");
        Thread demo = new Thread(test1);
        Test1 test2 = new Test1("线程B");
        Thread demo1 = new Thread(test2);
        Test1 test3 = new Test1("线程C");
        Thread demo2 = new Thread(test3);
                                                                                                                                                                                                                                                                                                                                        
        demo.start();
        demo1.start();
        demo2.start();
    }
}

某一次的执行结果为

线程A运行...0

线程A运行...1

线程A运行...2

线程B运行...0

线程B运行...1

线程A运行...3

线程C运行...0

线程A运行...4

线程B运行...2

线程B运行...3

线程C运行...1

线程B运行...4

线程C运行...2

线程C运行...3

线程C运行...4


Thread也是实现Runnable接口的，Thread中的run方法调用的是Runnable接口的run方法。Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式。


Thread和Runnable的区别：

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。


如果是一个买票系统，如果count表示的是车票的数量，使用Runnable接口

public class MyThread implements Runnable{
    private int ticket = 5;
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (this.ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "正在买票" + this.ticket--);
//              this.ticket--;//不可以分开写，线程级别，会出现不同步...
            }
        }
    }
}
public static void main(String[] args) {
    MyThread mt = new MyThread();
    new Thread(mt, "1号窗口").start();
    new Thread(mt, "2号窗口").start();
    new Thread(mt, "3号窗口").start();
}

某一次的执行结果为

1号窗口正在买票5

3号窗口正在买票3

2号窗口正在买票4

3号窗口正在买票1

1号窗口正在买票2


总结：

实现Runnable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

建议尽量使用Runnable接口


public class Test3 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
    public static void main(String[] args) {
        Test3 test = new Test3();
        new Thread(test, "A").start();
        new Thread(test, "B").start();
        new Thread(test).start();
    }
}

某一次的执行结构为

A

B

B

B

Thread-0

Thread-0

A

A

Thread-0



如果我们没有指定名字的话，系统自动提供名字。

提醒一下大家：main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM实习在就是在操作系统中启动了一个进程。


判断线程是否启动

public class Test4 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
    public static void main(String[] args) {
        Test4 test = new Test4();
        Thread demo = new Thread(test);
        System.out.println("线程启动之前---》" + demo.isAlive());
        demo.start();
        System.out.println("线程启动之后---》" + demo.isAlive());
    }
}

某一次的执行结果为

线程启动之前---》false

线程启动之后---》true

Thread-0

Thread-0

Thread-0


主线程也有可能在子线程结束之前结束。并且子线程不受影响，不会因为主线程的结束而结束。


线程的强制执行

public class Test5 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
    public static void main(String[] args) {
        Test5 t = new Test5();
        Thread demo = new Thread(t, "线程");
        demo.start();
        for (int i = 0; i < 10; ++i) {
            if (i > 5) {
                try {
                    demo.join(); // 强制执行demo
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main 线程执行-->" + i);
        }
    }
}

某一次的执行结果为

main 线程执行-->0

线程

线程

线程

线程

线程

线程

线程

线程

线程

线程

main 线程执行-->1

main 线程执行-->2

main 线程执行-->3

main 线程执行-->4

main 线程执行-->5

main 线程执行-->6

main 线程执行-->7

main 线程执行-->8

main 线程执行-->9


线程的休眠

public class Test6 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            try {
                System.out.println(new Date());
                Thread.sleep(2000);//休眠2000毫秒
                System.out.println(new Date());
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
    public static void main(String[] args) {
        Test6 t = new Test6();
        Thread demo = new Thread(t, "线程");
        demo.start();
    }
}

某一次的执行结果

Thu May 15 15:01:11 CST 2014

Thu May 15 15:01:13 CST 2014

线程0

Thu May 15 15:01:13 CST 2014

Thu May 15 15:01:15 CST 2014

线程1

Thu May 15 15:01:15 CST 2014

Thu May 15 15:01:17 CST 2014

线程2


线程的中断

public class Test7 implements Runnable {
    public void run() {
        System.out.println("执行run方法");
        System.out.println(new Date());
        try {
            Thread.sleep(10000);
            System.out.println("线程完成休眠");
        } catch (Exception e) {
            System.out.println("休眠被打断");
            return; // 返回到程序的调用处
        }
        System.out.println("线程正常终止");
    }
    public static void main(String[] args) {
        Test7 t = new Test7();
        Thread demo = new Thread(t, "线程");
        demo.start();
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        demo.interrupt(); // 2s后中断线程
        System.out.println(new Date());
    }
}

某一次的执行结果

执行run方法

Thu May 15 15:05:04 CST 2014

Thu May 15 15:05:06 CST 2014

休眠被打断


守护线程

public class Test8 implements Runnable{
    public void run() {
        while (true) {
            System.out.println(Thread.currentThread().getName() + "在运行");
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Test8 t = new Test8();
        Thread demo = new Thread(t, "线程");
        demo.setDaemon(true);//守护线程：守护线程则是用来服务用户线程的
//如果没有其他用户线程在运行，那么就没有可服务对象，也就没有理由继续下去。
        demo.start();
        System.out.println("Hello world!!!");
    }
}

执行结果

Hello world!!!

线程在运行

线程在运行

线程在运行

线程在运行

线程在运行

如果没有System.out.println("Hello world!!!");这句，run方法里面的语句不会执行


线程的优先级

public class Test9 implements Runnable {
    public void run() {
        for (int i = 0; i < 5; ++i) {
            System.out.println(Thread.currentThread().getName() + "运行" + i);
        }
    }
    public static void main(String[] args) {
        Thread h1 = new Thread(new Test9(), "A");
        Thread h2 = new Thread(new Test9(), "B");
        Thread h3 = new Thread(new Test9(), "C");
        h1.setPriority(8);
        h2.setPriority(2);
        h3.setPriority(6);
        h1.start();
        h2.start();
        h3.start();
    }
}

某一次的执行结果

A运行0

A运行1

A运行2

B运行0

C运行0

B运行1

A运行3

B运行2

C运行1

B运行3

A运行4

B运行4

C运行2

C运行3

C运行4

谁先执行还是取决于谁先去的CPU的资源，主线程的优先级是5


线程的礼让

在线程操作中，也可以使用yield（）方法，将一个线程的操作暂时交给其他线程执行

public class Test10 implements Runnable {
    public void run() {
        for (int i = 0; i < 5; ++i) {
            System.out.println(Thread.currentThread().getName() + "运行" + i);
            if (i == 2) {
                System.out.println("线程的礼让");
                Thread.currentThread().yield();//将一个线程的操作暂时交给其他线程执行
            }
        }
    }
    public static void main(String[] args) {
        Thread h1 = new Thread(new Test10(), "A");
        Thread h2 = new Thread(new Test10(), "B");
        h1.start();
        h2.start();
    }
}

某一次的执行结果

A运行0

B运行0

B运行1

A运行1

B运行2

线程的礼让

B运行3

B运行4

A运行2

线程的礼让

A运行3

A运行4


线程同步

在买票的程序中需要考虑线程同步保证数据不出错

格式

synchronized（同步对象）{
                                                                                  
 //需要同步的代码
                                                                                  
}

例

public class Test11 implements Runnable {
    private int count = 5;
    @Override
    public void run() {
        for (int i = 0; i < 10; ++i) {
            synchronized (this) {//线程同步
                if (count > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println(count--);
                }
            }
        }
    }
    public static void main(String[] args) {
        Test11 t = new Test11();
        Thread thread1 = new Thread(t);
        Thread thread2 = new Thread(t);
        Thread thread3 = new Thread(t);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

执行结果

5

4

3

2

1

每秒钟输出一个


也可以采用同步方法。

语法格式为

synchronized 方法返回类型方法名（参数列表）{
                                                          
    // 其他代码
                                                          
}

采用同步方法解决上面的问题

public class Test12 implements Runnable {
    private int count = 5;
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            sale();
        }
    }
    public synchronized void sale() {// 同步方法
        if (count > 0) {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(count--);
        }
    }
                                                      
    public static void main(String[] args) {
        Test12 t = new Test12();
        Thread thread1 = new Thread(t);
        Thread thread2 = new Thread(t);
        Thread thread3 = new Thread(t);
                                                          
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

执行效果和上面的同步线程完全一样。

当多个线程共享一个资源的时候需要进行同步，但是过多的同步可能导致死锁。

经典的生产者和消费者问题············To be continued...

本文出自 “阿凡达” 博客，请务必保留此出处http://shamrock.blog.51cto.com/2079212/1410738

java多线程execute_Java多线程
weixin_34704521的博客
02-16 2856
Java多线程之Executor、ExecutorService、Executors、Callable、Future与FutureTask1. 引子初学Java多线程，常使用Thread与Runnable创建、启动线程。如下例:Thread t1 = new Thread(newRunnable() {@Overridepublic voidrun() {System.out.println(Th...
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
张彦峰的博客
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
学python第十七弹 for循环1
weixin_48822677的博客
05-07 857
测试题 1 运行这个程序会得到什么输出： my_number = 7 if my_number <20: print(' Under 20') else: print('20 or over') 2 基于第一个问题中的程序，如果把 my_number 改为25，输出会是什么？ 3 要检查一个数是否大于 30 但小于 40 ，要用哪种 if 语句？ 4 要检查用户输入的字母 ‘ Q’ 是大写还是小写，要使用哪种 if 语句？ 动手试一试 1 一家商场在降价促销。如果购买金
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程实战-CountDownLatch模拟压测实现
热门推荐
qq_35716689的博客
03-17 25万+
当多个线程需要协调和同步执行任务时，Java 中的 CountDownLatch（倒计时器）是一个常用的工具类。它可以帮助开发者实现线程之间的同步，确保某些线程在其他线程完成任务后再继续执行。牵着猫散步的鼠鼠。本文将介绍 CountDownLatch 的基本原理、用法以及示例代码，最后会使用CountDownLatch完成一个简单的压测实现。
Java多线程——线程同步
u010759175的专栏
12-28 3196
1.不安全的买票 //不安全的买票 //线程不安全，有负数或者多人买到同一张票 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"苦逼的我").start(); new Thread(buyTicket,"牛逼的你们").start(); new Thread(buyTic
JAVA多线程是什么
qq_45022104的博客
08-31 4318
一、 什么是多线程： 我们现在所使用操作系统都是多任务操作系统(早期使用的DOS操作系统为单任务操作系统)，多任务操作指在同一时刻可以同时做多件事(可以同时执行多个程序)。 多进程:每个程序都是一个进程，在操作系统中可以同时执行多个程序,多进程的目的是为了有效的使用CPU资源，每开一个进程系统要为该进程分配相关的系统资源(内存资源) 多线程:线程是进程内部比进程更小的执行单元(执行流|程序片段),每个线程完成一个任务,每个进程内部包含了多个线程每个线程做自己的事情，在进程中的所有线程共享该进程的资源； 主
java多线程使用教程
鹏鹏2077
04-25 5656
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
【Java多线程的使用详解】
Java之行
04-19 2554
Java多线程的使用详解
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
JAVA多线程技术分享-39页PPT(winding)
05-10
Java多线程技术是软件开发中的重要组成部分，尤其在高并发场景下不可或缺。本文将深入探讨多线程技术的关键知识点，以及在实际开发中容易遇到的问题。 首先，基础概念是理解多线程的关键。`Thread.sleep(0)`看似无...
python3-wxpython4-webview-4.0.7-13.el8.tar.gz
最新发布
08-22
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
Python 基于BP神经网络实现鸢尾花的分类.zip
08-22
Python 基于BP神经网络实现鸢尾花的分类.zip
这篇文章详细介绍了极端灾害下电-气综合能源系统（IGES）的弹性评估方法，并通过MATLAB代码复现了相关模型（论文复现含详细代码及解释）
08-22
内容概要：该论文聚焦于电-气综合能源系统在极端灾害下的弹性评估，提出了一种考虑电网和天然气网络同时受极端事件扰动的系统模型。通过改进故障传播模型、建立电力网络、天然气网络及耦合装置的时变模型、引入储能装置恢复策略，提出了基于蒙特卡罗的弹性评估框架。该方法通过仿真验证，能够更准确地评估电-气综合能源系统的弹性，揭示了天然气网络在极端灾害下的重要性和电力网络的脆弱性，以及耦合效应对系统弹性的影响。 适合人群：能源系统研究人员、电力及天然气网络运营管理人员、从事综合能源系统设计与优化的工程师。 使用场景及目标：①评估极端灾害下电-气综合能源系统的弹性；②研究电网和天然气网络的耦合效应对系统弹性的影响；③探索储能装置在系统恢复中的作用；④为实际系统的韧性提升提供理论和技术支持。 其他说明：论文不仅提供了理论模型，还通过MATLAB代码实现了模型的具体算法，包括系统参数初始化、极端灾害场景生成、最优切负荷计算、弹性评估主程序、结果分析与可视化等。此外，论文指出了现有研究的局限性，并对未来的研究方向进行了展望，如经济优化、灾害特异性建模、多能源耦合系统研究等。
基于Python的习讯云命令行客户端（签到）.zip
08-22
基于Python的习讯云命令行客户端（签到）.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值