Java 并发线程实例

最新推荐文章于 2024-05-27 09:49:55 发布
最新推荐文章于 2024-05-27 09:49:55 发布
阅读量327 收藏 1
点赞数
分类专栏： java 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YL3126/article/details/119393812
版权

文章目录

实现方式

1. 继承 Thread
package thread;

public class ThreadService extends Thread{
    @Override
    public void run() {
        //RUN
        for (int i=0;i<200;i++){
            System.out.println("线程=============="+i);
        }
    }

    public static void main(String[] args) {
        ThreadService threadService=new ThreadService();
        ThreadService threadService2=new ThreadService();
//        threadService.run();
        threadService.start();//开启线程
        threadService2.start();//开启线程
        for (int i=0;i<2000;i++){
            System.out.println("线程="+i);
        }
    }
}
2.实现 Runnable 接口
package thread;

public class TestThread implements Runnable{

    public void run() {
        for (int i=0;i<200;i++){
            System.out.println("run...."+i);
        }
    }

    public static void main(String[] args) {
        TestThread testThread = new TestThread();
        new Thread(testThread).start();

        for (int i=0;i<200;i++){
            System.out.println("main...."+i);
        }
    }
}
3.实现 Callable 接口
package thread;

import java.util.concurrent.*;

public class TestCallable implements Callable<Boolean> {

    private String name;

    public TestCallable(String name) {
        this.name = name;
    }

    public Boolean call() throws Exception {
        System.out.println("->"+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        TestCallable testThread1 = new TestCallable("1号");
        TestCallable testThread2 = new TestCallable("2号");
        TestCallable testThread3 = new TestCallable("3号");
        //创建执行任务
        ExecutorService ex=Executors.newFixedThreadPool(3);

        //提交执行
        Future<Boolean> r1=ex.submit(testThread1);
        Future<Boolean> r2=ex.submit(testThread2);
        Future<Boolean> r3=ex.submit(testThread3);

        //获取结果
        boolean rs1=r1.get();
        boolean rs2=r2.get();
        boolean rs3=r3.get();

        //关闭服务
        ex.shutdown();
    }
}

线程特性相关

1.线程生命周期
package thread;

public class TestState {

    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(i);
            }

        });

        //线程状态 :NEW
        Thread.State state=thread.getState();
        System.out.println(state);

        //线程状态 :RUN
        thread.start();
        state=thread.getState();
        System.out.println(state);
        
        //等待线程
        while (state!=Thread.State.TERMINATED){
            state=thread.getState();
            System.out.println(state);
        }

        //结束
        state=thread.getState();
        System.out.println(state);

    }

}
2.线程礼让（不一定成功，具体还要看CPU的调度顺序）
package thread;
//礼让不一定成功
public class TestYield {
    private static MyYield  myYield=new MyYield();

    public static void main(String[] args) {
        new Thread(myYield,"A").start();
        new Thread(myYield,"B").start();
        new Thread(myYield,"C").start();
    }
}

class  MyYield implements Runnable{

    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始--------");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"结束--------");
    }
}
3.线程优先级（不一定成功，只是设置了，具体还要看CPU的调度顺序）
package thread;

public class TestPriority{

    public static void main(String[] args) {
        System.out.println("main->"+Thread.currentThread().getPriority());
        MyPriorty myPriorty = new MyPriorty();
        Thread thread1 = new Thread(myPriorty,"A");
        Thread thread2 = new Thread(myPriorty,"B");
        Thread thread3 = new Thread(myPriorty,"C");
        Thread thread4 = new Thread(myPriorty,"D");
        Thread thread5 = new Thread(myPriorty,"E");
        thread1.start();

        //设置优先级
        thread2.setPriority(3);
        thread2.start();

        thread3.setPriority(6);
        thread3.start();

        thread4.setPriority(10);
        thread4.start();

        thread5.setPriority(Thread.MAX_PRIORITY);//最大默认是 10 ,取值范围是 1-10
        thread5.start();

    }

}

class MyPriorty implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"->"+Thread.currentThread().getPriority());
    }

}
4.插队线程
package thread;

public class TestJoin implements Runnable{
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("VIP 线程="+i);
        }
    }

    public static void main(String[] args) {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 500; i++) {
            if(i==100){
                try {
                    thread.join();// 让他插队
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("主线程=="+i);
        }
    }
}
5.线程停止的推荐方式
package thread;

public class TestStop implements Runnable{

    private static boolean flag=true;

    public void run() {
        int i=0;
        while(flag){
            System.out.println("main->"+i++);
        }
    }

    public static void stop(){
            flag=false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 10000000; i++) {
            if(i>=900000){
                testStop.stop();
                System.out.println("STOP!!!");
                break;
            }
        }
    }
}
6.线程不安全与安全线程的演示
package thread;

import java.util.ArrayList;

public class TestSysList {
    public static void main(String[] args) {

        ArrayList<Object> list = new ArrayList<>();
        ArrayList<Object> unList = new ArrayList<>();

        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
                unList.add(Thread.currentThread().getName());
            }).start();
        }
        //这里要保证异步线程执行完，所以需要睡眠一下！
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("加锁=="+list.size());
        System.out.println("未加锁=="+unList.size());

    }
}
7.守护线程
package thread;

public class TestDeamon {
    public static void main(String[] args) {
        You you = new You();
        God god = new God();

        Thread threadYou = new Thread(you);
        Thread threadGod = new Thread(god);
        threadYou.start();
        threadGod.setDaemon(true);
        threadGod.start();
    }
}

//上帝(守护线程)
class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("守护....");
        }
    }
}

//人（默认线程）
class You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("执行。。。。。"+i);
        }
    }
}
8.线程死锁与解锁

死锁线程：

package thread;
//死锁
public class TestDealLock {
    public static void main(String[] args) {
        Makeup makeup = new Makeup();
        new Thread(makeup,"A").start();
        new Thread(makeup,"B").start();
    }
}

//口红
class Lipstick{
}

//镜子
class Mirror{
}

class Makeup extends Thread{

    //口红
    static Lipstick lipstick=new Lipstick();
    //镜子
    static Mirror mirror=new Mirror();

    @Override
    public void run() {
        making();
    }

    //开始化妆
    public void making(){
        String name=Thread.currentThread().getName();
        if(name=="A"){
            synchronized (lipstick){
                System.out.println(name+"==拿到了口红！");

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (mirror){
                    System.out.println(name+"==拿到了镜子！");
                }
            }
        }else{
            synchronized (mirror){
                System.out.println(name+"==拿到了镜子！");

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lipstick){
                    System.out.println(name+"==拿到了口红！");
                }
            }
        }

    }
}

解锁：

package thread;
//死锁
public class TestDealLock {
    public static void main(String[] args) {
        Makeup makeup = new Makeup();
        new Thread(makeup,"A").start();
        new Thread(makeup,"B").start();
    }
}

//口红
class Lipstick{
}

//镜子
class Mirror{
}

class Makeup extends Thread{

    //口红
    static Lipstick lipstick=new Lipstick();
    //镜子
    static Mirror mirror=new Mirror();

    @Override
    public void run() {
        making();
    }

    //开始化妆
    public void making(){
        String name=Thread.currentThread().getName();
        if(name=="A"){
            synchronized (lipstick){
                System.out.println(name+"==拿到了口红！");

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
               
            }
            //解锁
             synchronized (mirror){
                    System.out.println(name+"==拿到了镜子！");
            }
        }else{
            synchronized (mirror){
                System.out.println(name+"==拿到了镜子！");

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
               
            }
            //解锁
             synchronized (lipstick){
                    System.out.println(name+"==拿到了口红！");
                }
        }

    }
}
9.JUC下的安全list
package thread;

import java.util.concurrent.CopyOnWriteArrayList;

public class TestJuc {

    public static void main(String[] args) {
        CopyOnWriteArrayList<Object> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }

        //睡眠一下，保证他执行完
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(list.size());

    }

}

线程池详解

请参考此文：https://www.freesion.com/article/42591110359/

会飞的小蜗
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Thinking in Java---多线程仿真：银行出纳员仿真＋饭店仿真＋汽车装配工厂仿真
荒野孤鹰
02-27 3082
多线程一个很有意思的作用就是用于仿真，这篇博客就会结合几个仿真实例来综合运用一下前面所学的多线程并发知识。一.银行出纳员仿真 问题描述：银行会有很多来办业务的顾客，他们会排队等待服务；对于银行方面他们派出出纳员来服务顾客，如果排队的顾客数量过多，银行就会增加 出纳员的数量，如果顾客的数目过少，则减少出纳员的数目；总之要保持一个平衡。仿真思路:封装Customer类来表示顾客，每个顾客对象都会有一
java 多线程并发实例
03-11
代码里面包含一个并发4个线程同时运行 全部开始 全部停止 单个停止还有点问题。 还有生产者消费者 里面的里面能帮助你理解多线程的运用！
java 并发实例_java一些常用并发工具示例
weixin_42509409的博客
02-20 165
最近把《java并发编程实战》-Java Consurrency in Practice 重温了一遍，把书中提到的一些常用工具记录于此：一、闭锁(门栓)-CountDownLatch适用场景：多线程测试时，通常为了精确计时，要求所有线程都ready后，才开始执行，防止有线程先起跑，造成不公平，类似的，所有线程执行完，整个程序才算运行完成。/*** 闭锁测试(菩提树下的杨过 http://yjmy...
全面详解Java并发编程：从基础到高级应用
最新发布
微笑听雨
05-27 8419
Java并发编程提供了强大的工具和框架，帮助开发者有效管理多线程任务，提升应用程序性能。理解并掌握基本概念、线程管理、同步机制和高级并发工具，并遵循最佳实践，可以编写出高效、安全、可靠的并发程序。
Java并发 示例
baiiu
03-30 534
1. 死锁private static class DeadLockRunnable implements Runnable { private final Object objA; private final Object objB; DeadLockRunnable(Object objA, Object objB) { this.objA = objA;
java 并发编程实例_java并发编程应用实例
weixin_30937427的博客
02-13 217
package com.juchaosoft.test;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/*** 线程按序交替* @author wang-xiaoming**/publ...
Java多线程并发执行demo代码实例
08-18
"Java多线程并发执行demo代码实例" 在Java编程中，多线程并发执行是非常重要的概念，它可以提高程序的执行效率和响应速度。今天，我们通过一个demo代码实例来学习Java多线程并发执行的实现。 知识点1：泛型 在...
Java多线程实例
09-03
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高程序的效率和响应速度。在Java中，实现多线程有两种主要方式：继承`java....通过实例学习和理解这些概念，有助于更好地掌握Java多线程编程。
java并发编程实例分析
08-26
Java并发编程是Java程序设计中的关键部分，它涉及到如何在多线程环境下高效、安全地执行任务。在大部分实际业务场景中，并发编程都是不可或缺的，比如处理HTTP请求，通过并发处理可以让单台服务器同时处理多个请求，...
JAVA多线程编程实例详解
08-25
JAVA多线程编程实例详解 JAVA多线程编程是指在一个程序中可以同时运行多个线程，以提高程序的执行效率和响应速度。JAVA多线程编程可以通过继承Thread类或实现Runnable接口来实现。 在JAVA中，线程是系统进行资源...
Java并发的例子
coast1的专栏
11-12 183
import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.Executor; import java.util.concurrent.Executors; public class Main { pr...
Java 并发编程示例测试
02-26
Java 并发编程示例测试 concurrent包下的测试
java多线程并发编程例子
03-08
关于java.util.concurrent多线程核心包内各种线程资源的使用场景例子
java 并发编程实例_Java并发编程案例解读
weixin_39922929的博客
02-13 277
经过前面几节的学习，了解了多线程概念、Thread类的应用、多线程数据同步存在的问题及解决方法。本节给出一个并发编程实例应用案例，通过案例的学习，可以灵活地把多线程知识应用到实际编程中，解决在项目开发过程中遇到的并发编程问题。在进入案例之前，先了解一下实现Java同步机制的几个方法，Java.lang.object类提供了wati()、notify()、notifyAll()方法，它们与synch...
java 并发编程实例_java并发编程实例分析
weixin_34324618的博客
02-13 314
java并发编程是java程序设计语言的一块重点，在大部分的业务场景中都需要并发编程。比如：并发的去处理http请求，这样就可以使得一台机器同时处理多个请求，大大提高业务的响应效率，从而使用用户体验更加流畅。java如何并发编程，要注意以下几个方面：1、java语言中的多线程操作：创建和启动线程的几种方式。2、共享变量的同步问题，要保证线程安全，辨别哪些变量是线程安全的、那些变量是线程不安全的，对...
Java并发编程组件实例大全一：线程
yunyun1886358的专栏
03-19 490
#mermaid-svg-v4Hzg4hJ0xr3Rdan .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-v4Hzg4hJ0xr3Rdan .label text{fill:#333}#mermaid-svg-v4Hzg4hJ0xr3Rdan .node rect,#mermaid-svg-v4Hzg4hJ0x
java 并发控制_JAVA多线程的并发控制
weixin_39966909的博客
02-12 178
java的多线程实现主要有两种，一种是继承Thread，一种是实现Runnable接口，这个是java最基本的多线程知识。这里要补充一下，runnable接口中的run方法是不返回任何内容的，如果想返回一个对象可以试试用concurrent包中的Callable接口来替换runable接口的实现Executor.submit(Callable instance) 将返回一个Futrue>实例...
java并发编程应用实例-多线程！
m0_55233348的博客
05-09 568
多核处理器现在已广泛应用于服务器、台式机和便携机硬件。它们还扩展到到更小的设备，如智能电话和平板电脑。由于进程的线程可以在多个内核上并行执行，因此多核处理器为并发编程打开了一扇扇新的大门。为实现应用程序的最大性能，一项重要的技术就是将密集型任务拆分成可以并行执行的若干小块，以便最大程度利用计算能力。 传统上，处理并发（并行）编程一直很困难，因为您不得不处理线程同步和共享数据的问题。Groovy (GPar)、Scala 和 Clojure 社区的努力已经证明，人们对 Java 平台上并发编程的语言级支持的兴
Java 多线程与并发(案例 + 应用)
IT_Holmes的博客
07-10 3458
1. 传统 创建线程的两种方式 2. 传统 定时器技术 3. 传统线程 互斥技术 4. 传统线程 同步通信技术 5. 线程范围内 共享变量 概念和作用 6. ThreadLocal类及应用技巧 7. 多个线程之间 共享数据的方式 8. Java 原子性类的应用 9. Java 线程并发库的应用(线程池) 10. Callable 与 future的应用 11. 线程锁的技术 12. Java 读写锁技术的使用 13. Java 条件阻塞condition的应用 14. Semaphore(信号灯)同步工具
java 多线程 并发实例_Java 多线程（并发）
weixin_35370061的博客
02-21 418
线程释义使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。一个Thread类实例只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。Java中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。一个Java应用总是从main()方法开始运行，mian()方法运行在一个线程内，它被称为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

会飞的小蜗

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

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

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

打赏作者

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

抵扣说明：

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

余额充值