javaSE-多线程

最新推荐文章于 2024-08-01 15:05:06 发布
最新推荐文章于 2024-08-01 15:05:06 发布
阅读量86 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55547115/article/details/131973550
版权

本章概述：

一、api

1、JoinDemo

package com.tensent.class4.api;
 
public class JoinDemo {
 
    public static void main(String[] args) {
        RunDemo runDemo = new RunDemo();
        Thread thread = new Thread(runDemo);
        thread.start();
 
        for (int i = 0; i < 10; i++) {
            if(i == 3){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "------------" + i);
        }
    }
}

2、RunDemo

package com.tensent.class4.api;
 
public class RunDemo implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "------------" + i);
        }
    }
}

3、SleepDemo

package com.tensent.class4.api;
 
public class SleepDemo {
 
    public static void main(String[] args) {
        RunDemo runDemo = new RunDemo();
        Thread thread = new Thread(runDemo);
        thread.start();
 
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "------------" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4、StopDemo

package com.tensent.class4.api;
 
public class StopDemo {
 
    public static void main(String[] args) {
        RunDemo runDemo = new RunDemo();
        Thread thread = new Thread(runDemo);
        thread.start();
 
        for (int i = 0; i < 100; i++) {
            if(i == 2){
                thread.stop();
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "------------" + i);
        }
    }
}

5、ThreadApiDemo

package com.tensent.class4.api;
 
public class ThreadApiDemo {
 
    public static void main(String[] args) {
        //获取当前线程的实例
        Thread thread = Thread.currentThread();
        //获取当前线程的名称
        System.out.println(thread.getName());
 
        //获取线程的优先级，一般情况优先级是0-10之间的整数，默认优先级是5，特殊情况下也可以是0-100之间的整数。
        /*
         *   作用：
         *     数值越大代表优先级越高，但是优先级越高并不一定意味着它会被先执行，而是说优先级高的会执行的效率更大一些，仅此而已。
         */
        System.out.println(thread.getPriority());
 
    }
}

6、YieldDemo

package com.tensent.class4.api;

public class YieldDemo {
 
    public static void main(String[] args) {
        RunDemo runDemo = new RunDemo();
        Thread thread = new Thread(runDemo);
        thread.start();
 
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "------------" + i);
            if(i == 6){
                //线程礼让一次，进入就绪状态，如果就绪队列中没有其他线程或者其他线程没有它自己抢占CPU资源快的话，那么它自己会快读的抢占CPU资源进行运行状态。
                Thread.yield();
            }
        }
    }
}

二、proxy

1、JiaShi

package com.tensent.class4.proxy;
 
public class JiaShi implements KindWomen {
    @Override
    public void makeEyesWithMen() {
        System.out.println("贾氏抛媚眼... ...");
    }
 
    @Override
    public void playWithMen() {
        System.out.println("贾氏... ...");
    }
}

2、KindWomen

package com.tensent.class4.proxy;
 
public interface KindWomen {
 
    /*
     *  抛媚眼
     */
    public void makeEyesWithMen();
 
    public void playWithMen();
 
}

3、PanJinLian

package com.tensent.class4.proxy;
 
public class PanJinLian implements KindWomen {
    @Override
    public void makeEyesWithMen() {
        System.out.println("潘金莲抛媚眼... ..");
    }
 
    @Override
    public void playWithMen() {
        System.out.println("潘金莲... ...");
    }
}

4、WangPo

package com.tensent.class4.proxy;
 
public class WangPo implements KindWomen {
 
    private KindWomen kindWomen;
 
    public WangPo(){
        this.kindWomen = new PanJinLian();
    }
 
    public WangPo(KindWomen kindWomen){
        this.kindWomen = kindWomen;
    }
 
    @Override
    public void makeEyesWithMen() {
        this.kindWomen.makeEyesWithMen();
    }
 
    @Override
    public void playWithMen() {
        this.kindWomen.playWithMen();
    }
}

5、XiMenQing

package com.tensent.class4.proxy;
 
public class XiMenQing {
 
    public static void main(String[] args) {
//        WangPo wangPo = new WangPo();
//        wangPo.makeEyesWithMen();
//        wangPo.playWithMen();
        JiaShi jiaShi = new JiaShi();
        WangPo wangPo = new WangPo(jiaShi);
        wangPo.makeEyesWithMen();
        wangPo.playWithMen();
    }
}

三、ThreadDemo
1、ThreadDemo

 
/**
 * 实现多线程的两种方式：
 *  第一种实现方式：继承Thread类
 *      1、需要继承Thread类
 *      2、必须要重写run方法，指的是核心执行的逻辑
 *      3、线程在启动的时候，不要直接调用run方法，而是要通过start()来进行调用
 *      4、每次运行相同的代码，出来的结果可能不一样，原因在于多线程谁先抢占资源无法进行人为控制
 *  第二种实现方式：使用了代理设计模式
 *      1、实现Runnable接口
 *      2、重写run方法
 *      3、创建Thread对象，将刚刚创建好的runnable的子类实现作为thread的构造参数
 *      4、通过thread.start()进行启动
 *    两种实现方式哪种用的比较多
 *    推荐使用第二种方式，
 *      1、java是单继承，将继承关系留给最需要的类
 *      2、使用runnable接口之后不需要给共享变量添加static关键字，每次创建一个对象，作为共享对象即可
 *   线程的生命周期：
 *      1、新生状态(新建状态)：
 *          当创建好当前线程对象之后，没有启动之前（调用start方法之前）
 *          ThreadDemo thread = new ThreadDemo()
 *          RunnableDemo run = new RunnableDemo()
 *      2、就绪状态：准备开始执行，并没有执行，表示调用start方法之后
 *          当对应的线程创建完成，且调用start方法之后，所有的线程会添加到一个就绪队列中，所有的线程同时去抢占cpu的资源
 *      3、运行状态：当当前进程获取到cpu资源之后，就绪队列中的所有线程会去抢占cpu的资源，谁先抢占到谁先执行，在执行的过程中就叫做运行状态
 *          抢占到cpu资源，执行代码逻辑开始
 *      4、死亡状态：当运行中的线程正常执行完所有的代码逻辑或者因为异常情况导致程序结束叫做死亡状态
 *              进入的方式：
 *                  1、正常运行完成且结束
 *                  2、人为中断执行，比如使用stop方法
 *                  3、程序抛出未捕获的异常
 *      5、阻塞状态：在程序运行过程中，发生某些异常情况，导致当前线程无法再顺利执行下去，此时会进入阻塞状态，进入阻塞状态的原因消除之后，
 *                  所有的阻塞队列会再次进入到就绪状态中，随机抢占cpu的资源，等待执行
 *          进入的方式：
 *              sleep方法
 *              等待io资源
 *              join方法（代码中执行的逻辑）
 *
 *      注意：
 *          在多线程的时候，可以实现唤醒和等待的过程，但是唤醒和等待操作的对应不是thread类
 *             而是我们设置的共享对象或者共享变量
 *      多线程并发访问的时候回出现数据安全问题：
 *          解决方式：
 *              1、同步代码块
 *                  synchronized(共享资源、共享对象，需要是object的子类){具体执行的代码块}
 *              2、同步方法
 *                  将核心的代码逻辑定义成一个方法，使用synchronized关键字进行修饰，此时不需要指定共享对象
 *
 */
public class ThreadDemo {
 
    public static void main(String[] args) {
        /*
             一个java程序运行的步骤:
                1、编写java源文件，源程序；
                2、使用javac命令编译.java文件，生成对应的.class字节码文件
                3、使用java命令解释执行.class文件中存在的类
         */
 
        for(int i = 0; ;i++){
            System.out.println("hello!");
        }
    }
}

四、ticket
1、RunnableTicket
 

package com.tensent.class4.ticket;
 
/**
 * 出现的问题：
 *    1、卖票的次序是混乱的；
 *    2、每个窗口不能平均的卖票，分配不均，有些窗口卖了很多票，有些窗口一张票都没卖。这个不符合显示情况。
 *
 */
public class RunnableTicket implements Runnable {
 
    //资源（火车票）
    private int ticket = 10;
 
    @Override
    public void run() {
        for(int i =0; i <100;i++){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "----------正在卖第" + (ticket--) +"张票！");
            }
        }
    }
 
    public static void main(String[] args) {
        RunnableTicket runnableTicket = new RunnableTicket();
 
        Thread t1 = new Thread(runnableTicket,"1号窗口");
        Thread t2 = new Thread(runnableTicket,"2号窗口");
        Thread t3 = new Thread(runnableTicket,"3号窗口");
        Thread t4 = new Thread(runnableTicket,"4号窗口");
 
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

2、RunnableTicket2
 

package com.tensent.class4.ticket;
 
/**
 * 出现的问题：
 * 1、卖票的次序是混乱的；
 * 2、每个窗口不能平均的卖票，分配不均，有些窗口卖了很多票，有些窗口一张票都没卖。这个不符合显示情况。
 */
public class RunnableTicket2 implements Runnable {
 
    //资源（火车票）
    private Integer ticket = 10;
 
//    String str = "";
 
    @Override
    public void run() {
        //定义一个共同的锁
        /*
               当多个线程共同访问同一个资源的时候，会出现线程安全问题，此时解决办法之一是加锁，
               在java中要求锁是对象类型，任何对象都是可以的，但是需要保证多个线程访问的是同一把锁。
               程序中锁的名称特别的锁：
               1、锁旗标；
               2、同步监视器；
               3、同步锁；
               4、互斥锁；
               5、对象锁；
               6、锁
               ... ...
         */
//        String str = "";
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (ticket) {
//            synchronized (this){
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "----------正在卖第" + (ticket--) + "张票！");
                }
            }
 
        }
    }
 
    public static void main(String[] args) {
        RunnableTicket2 runnableTicket = new RunnableTicket2();
 
        Thread t1 = new Thread(runnableTicket, "1号窗口");
        Thread t2 = new Thread(runnableTicket, "2号窗口");
        Thread t3 = new Thread(runnableTicket, "3号窗口");
        Thread t4 = new Thread(runnableTicket, "4号窗口");
 
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

3、RunnableTicket3
 

/**

 * <p>
 * 出现的问题：
 * 1、卖票的次序是混乱的；
 * 2、每个窗口不能平均的卖票，分配不均，有些窗口卖了很多票，有些窗口一张票都没卖。这个不符合显示情况。
 */
public class RunnableTicket3 implements Runnable {
 
    //资源（火车票）
    private int ticket = 10;
 
    @Override
    public void run() {
        //定义一个共同的锁
        /*
               当多个线程共同访问同一个资源的时候，会出现线程安全问题，此时解决办法之一是加锁，
               在java中要求锁是对象类型，任何对象都是可以的，但是需要保证多个线程访问的是同一把锁。
               程序中锁的名称特别的锁：
               1、锁旗标；
               2、同步监视器；
               3、同步锁；
               4、互斥锁；
               5、对象锁；
               6、锁
               ... ...
         */
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.sale();
        }
    }
 
    public synchronized void sale() {
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "----------正在卖第" + (ticket--) + "张票！");
        }
    }
 
    public static void main(String[] args) {
        RunnableTicket3 runnableTicket = new RunnableTicket3();
 
        Thread t1 = new Thread(runnableTicket, "1号窗口");
        Thread t2 = new Thread(runnableTicket, "2号窗口");
        Thread t3 = new Thread(runnableTicket, "3号窗口");
        Thread t4 = new Thread(runnableTicket, "4号窗口");
 
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

4、ThreadTicket
package com.tensent.class4.ticket;
 

 * 模拟4个窗口卖共同的10张火车票
 *
 * 出现的问题：
 *      1、不是在共享10张票的资源，而是各个窗口在卖自己的10张票，出现这种情况的原因每次都new的新的线程，此时ticket变量是和对象相关的，所以对应的就有了4个10张票出现；
 *      2、卖票的次序是有问题的。
 *
 */
public class ThreadTicket extends  Thread {
 
    //资源（火车票）
    private static int ticket = 10;
 
    public ThreadTicket(String threadName){
        super(threadName);
    }
 
    @Override
    public void run() {
        for(int i =0; i <100;i++){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "----------正在卖第" + (ticket--) +"张票！");
            }
        }
    }
 
    public static void main(String[] args) {
        ThreadTicket t1 = new ThreadTicket("1号窗口");
        ThreadTicket t2 = new ThreadTicket("2号窗口");
        ThreadTicket t3 = new ThreadTicket("3号窗口");
        ThreadTicket t4 = new ThreadTicket("4号窗口");
 
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
66package com.tensent.class4.thread;
 
import com.tensent.class2.ticket.ThreadTicket;
 
public class RunnableDemo implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i<10;i++){
            System.out.println(Thread.currentThread().getName() + "------" + i);
        }
    }
    public static void main(String[] args) {
        //创建线程对象
        RunnableDemo runnableDemo = new RunnableDemo();
        //启动线程---使用java中的设计模式（代理模式）
        Thread thread = new Thread(runnableDemo);
        thread.start();
 
        for(int i = 0; i<10;i++){
            System.out.println(Thread.currentThread().getName() + "------" + i);
        }
    }
}

魏玉柱java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaSE --- 多线程
MemoryTa的博客
08-06 224
多线程。。概述生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。所谓生产者消费者问题，实际上主要是包含了两类线程：一类是生产者线程用于生产数据一类是消费者线程用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为Object类的等待和唤醒方法。............
JavaSE——多线程
qq_46002941的博客
01-22 188
记录看视频自学多线程的一些笔记
JavaSE-多线程
apple_59745077的博客
01-24 945
java中共提供了1~10 ,10个优先级Thread中提供了三个优先级常量，MIN_PRIORITY代表1，NORM_PRIORITY代表5，MAX_PRIORITY代表10。默认优先级为5，子类从父类继承优先级问题: 多个线程执行的不确定性引起执行结果的不确定性多个线程对同一个数据或对象的共享会造成操作的不完整性，会破坏数据线程同步:当多个线程同时操作一个数据的时候，为了保证数据的一致性和正确性，需要使用线程同步，线程同步是一种数据的安全机制。
JavaSE-多线程基础-基于多线程的计时器应用
wexin_mylove的博客
03-28 1466
JavaSE的多线程的创建以及对于多线程安全的保护，多线程通信以及对于多线程的应用
JavaSE-多线程（4）- CAS
sql2008help的博客
11-13 689
JavaSE-多线程（4）- CAS CAS （CompareAndSwap）举例 例1：在此例中，有 THREAD_COUNT （20）个数量的线程调用 AtomicTest 对象m方法，对属性count进行自增操作，最后在主线程打印count的最终结果为20，由于存在多线程多并发访问count，所以在自增操作前使用synchronized关键字对AtomicTest对象进行了锁定。 package com.hs.example.base.multithread.day01; public class
JavaSE专题-多线程总结.doc
06-03
JavaSE专题的多线程是Java编程中至关重要的一部分，它涉及到如何在单个程序中同时执行多个任务。以下是对多线程技术的详细说明： 1. **多线程技术介绍** - **进程**：一个进程是操作系统分配给应用程序的内存空间...
javase之多线程技术
10-16
Java中的多线程技术是Java进阶学习的重要组成部分，它涉及到并发编程的理论与实践，旨在提高程序的执行效率和响应速度。以下是对多线程技术的详细解释： 1. **CPU调度算法原理** - **先来先服务（FCFS）**：按照...
JavaSE多线程
09-15
JavaSE的多线程特性是其强大的功能之一，它允许开发者编写能够同时处理多个任务的程序，从而提高程序的效率和响应性。在Java中，线程是程序执行的最小单位，而进程则是资源分配的基本单位。每个Java应用程序至少有一...
JavaSE异常与多线程
06-04
入门级笔记，适合查漏补缺。
JavaSE 多线程资料
04-06
JavaSE 多线程是Java编程中至关重要的概念，它涉及到如何在单个程序中同时执行多个任务，从而提升程序的效率和响应性。在Java中，线程是程序执行的最小单位，与进程一同构成了操作系统的基础运行模型。 首先，线程...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 527
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
Karen198的博客
07-31 362
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
最新发布
weixin_55745942的博客
08-01 351
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 287
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 305
1.导入hutool的maven依赖。2.直接复制一下代码运行。
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 927
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Java并发（十一）一文搞懂Java并发各种容器
m0_58466443的博客
07-29 812
同步容器将所有对容器状态的访问都串行化，以保证线程安全性，这种策略会严重降低并发性。Java 1.5 后提供了多种并发容器，使用并发容器来替代同步容器，可以极大地提高伸缩性并降低风险。并发容器对应的普通容器描述HashMapJava 1.8 之前采用分段锁机制细化锁粒度，降低阻塞，从而提高并发性；Java 1.8 之后基于 CAS 实现。SortedMap基于跳表实现的ArrayListSet基于实现。SortedSet基于实现。Queue线程安全的无界队列。底层采用单链表。支持 FIFO。
【Java算法专场】二分查找(下）
zhyhgx的博客
07-27 897
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 66
④创建artifact。②点击加号创建，选择。
JavaSE多线程技术详解及常见问题分析
多线程技术是一种能够在同一进程中同时执行多个线程的技术。多线程技术可以提高程序的运行效率，充分利用计算机的多核处理器，使得程序能够更加灵活地处理各种任务。在Java中，多线程技术是非常重要的，因为它可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值