多线程的初步认识

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量87 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57972737/article/details/119304494
版权

多线程

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

线程的常用方法

1. Start();                 启动当前线程：调用当前线程的run()； 

2.run()；                  通常需要重写Thread类中的方法，将创建的线程要执行的操作声明在此方法中

3.currentThread();        静态方法，放回执行当前线程代码的线程

4.getName();                获取当前线程的名字

5.setName();                设置当前线程的名字

6.yield();                       释放当前CPU的执行权

7.join();                        在线程a中调用线程b的 join() ，此时线程a就进入阻塞状态，知道线程b完                                        全执行结束后，线程a才结束阻塞状态

8.sleep(long millitime);让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前                                      线程是阻塞状态。

9.isAlive() ;                  判断当前线程是否存活

线程的优先级

等级：最高：MAX_PRIORITY:10

           最低：MIX_PRIORITY:1

           默认：NORM_PRIORITY:5

涉及方法：getPrioity();  返回线程优先值

                  setPrioity(int newPrioity);改变线程优先级

优先级从概率上，高优先级先执行的几率高，并不意味着高优先级先执行，低优先级后执行。

public class MyThread extends Thread{
    public static void main(String[] args) {
    MyThread m = new MyThread();
    m.setPriority(Thread.MAX_PRIORITY);
    }

}

创建多线程的方式一：继承Thread

public class MyThread extends Thread{
   
    @Override
    public void run() {
        for (int i= 0;i<10;i++) {
            System.out.println("Thread"+i);
        }

    }
}

public class Dome {
    public static void main(String[] args) {
        //1.    创建一个任务对象
        MyThread m = new MyThread();
        //2.    执行这个线程
        m.start();

        //主线程运行任务
        for (int i= 0;i<10;i++) {
            System.out.println(i);
        }
    }
}

创建多线程的方式二：实现Runnable

        在Runnable中的 start();

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        //Runnable线程任务
        for (int i= 0;i<10;i++) {
            System.out.println("Runnable" + i);
        }
    }

}
public class Dome {

    public static void main(String[] args) {
        //1.    创建一个任务对象
        MyRunnable r = new MyRunnable();
        //2.    创建一个线程，并为其分配一个任务
        Thread t = new Thread(r);
        //3.    执行这个线程
        t.start();

        for (int i= 0;i<10;i++) {
            System.out.println("Runnable_Dome" + i);
        }
    }
}

实现Runnable  与继承Thread 相互比较：

开发中：优先选择：显现Runnable接口的方式
原因：1.实现的方式没有类的单继承性的局限性
      2.实现的方式更适合来处理多个线程有共享数据的情况
联系：public class Therad implements Runnable
相同点：两种方式都需要重写run(); 将线程要执行的逻辑声明在run中

线程： 分为 守护线程 和 用户线程

用户线程：当一个进程不包含任何存活的用户线程时，进程结束。
守护线程：守护用户线程，当最后一个用户线程结束时，所有守护线程自动结
public class THERAD {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MYRunnable());
        //设置t1为守护线程
        t1.setDaemon(true);
        t1.start();

        //主线程运行任务
        for (int i= 0;i<=5;i++) {
             //currentThread().getName()获取线路名称
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);//  sleep线程的休眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //给路线t1添加中断标记
        t1.interrupt();


    }
    static class MYRunnable implements Runnable{

        @Override
        public void run() {
            for (int i= 0;i<=10;i++) {
                    //currentThread().getName()获取线路名称
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);//  sleep线程的休眠
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    System.out.println("发现中断标记");
                    return;//被标记中断信号
                }
            }
        }
    }

}

线程的安全问题

方法一：同步代码块

               synchronized(同步监视器){

                        //操作共享数据的代码

                   }

class Window1 implements Runnable{

    private int ticket = 100;
    Object obj = new Object();//锁

    @Override
    public void run() {
        while (true) {
            synchronized(obj){
                if (ticket > 0) {
                    System.out.println("正在准备买票");
                    ticket--;
                    System.out.println("出票成功，余票" + ticket);
                }else {
                    break;
                }
            }
        }
    }
}

方法二：同步方法

private synchronized void shou(){

}
class Window implements Runnable{

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            shou();
        }

    }

    private synchronized void shou(){
                if (ticket > 0) {
                    System.out.println("正在准备买票");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "出票成功，余票" + ticket);
                }
    }
}

如果线程使用继承Thread时，继承Thread的对象不唯一，需要在锁上加上静态。

方法三：Lock锁

class Windowlock implements Runnable{

    private int ticket = 100;
        // 方法三：1. 创建ReentrantLock
    private ReentrantLock lock = new ReentrantLock(true);//添加true表示公平锁
    @Override
    public void run() {
        while (true){
            try {
                //2.调用lock();
                lock.lock();
                if (ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "售票，票号为：" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }finally {
                // 3.调用解锁的方法：unlock
                lock.unlock();
            }
        }
    }
}

 

带返回值的线程Callable

Callable的使用步骤

public class MyCallable {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //2. 创建 FutureTask 对象 ，并传入第1步Callable类对象
        Callable<Integer> c = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(c);
        //3. 通过Thread 启动线程
        new Thread(task).start();
        /*   task.isDone()  判断线程是否执行完毕 */
        /*   task.cancel(true)  取消当前线程继续执行 */
        Integer j = task.get();//获取线程的返回值
        System.out.println("返回值为：" + j);
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }

    //1. 实现Callable接口 ，实现call 方法
    static class MyCallable implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 10; i++) {
                Thread.sleep(100);
                System.out.println(i);
            }
            return 100;
        }
    }
}

Runnable 与 Callable 的相同点

  • 都是接口
  • 都可以编写多线程程序
  • 都采用Thread.start();启动线程

Runnable 与 Callable 的不同点 

  • Runnable没有返回值；Callable可以返回执行的结果
  • Callable接口的call() 允许抛出异常；Runnable的run()不能抛异常 

线程池的四种用法

  一、缓存线程池

public class Dome {

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "壹贰叁肆伍");
            }
        });

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "壹贰叁肆伍");
            }
        });
    }
}

  二、定长线程池
 

public class Dome {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "壹贰叁肆伍");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "壹贰叁肆伍");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "壹贰叁肆伍");

            }
        });

    }
}

  三、单线程线程池
 

public class Dome {

    public static void main(String[] args) {

        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "壹贰叁肆伍");
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "壹贰叁肆伍");
            }
        });

    }
}

  四、周期定长线程池

public class Dome {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("一二三四五");
            }
        },5, TimeUnit.SECONDS);
         
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("壹贰叁肆伍");
            }
        },5,1,TimeUnit.SECONDS);


    }
}

CN_HQL
关注
【JavaEE】初步认识多线程
2302_79806056的博客
08-08 1504
下面是一些关于线程的关键点：控制流：线程是进程内单一顺序的控制流，每个线程有自己的执行栈和寄存器状态，但共享所属进程的资源，如内存空间、文件句柄和信号。资源共享：在同一进程中，多个线程共享相同的虚拟地址空间、全局变量和其他进程级别的资源，这使得线程间的通信和数据共享比进程间更加高效和简单。独立调度：线程是独立调度和分派的基本单位，这意味着它们可以被操作系统调度来利用CPU时间，从而实现并行或并发执行。类型：
多线程——初步认识线程
comerun的博客
07-14 619
在我一开始学习多线程的时候，一直很疑惑的是，为什么要创造多线程，线程又是什么？其实很多时候问题就藏在我们的生活当中，我们也可以把编程的思想与现实生活联系起来就可以理解为什么Java之父要去专门设计线程。
线程初步认识
H48530的博客
06-28 751
线程认识线程(Thread)概念什么情况下需要线程创建Java线程Thread的几个常见属性如何创建Java线程start() vs run()Thread类常见的构造方法：线程中断调用方法等待一个线程线程的状态Thread.isXXX()Thread中常见静态方法观察线程状态工具 认识线程(Thread) 概念 线程属于进程的组成（每个进程中至少有一个线程（主线程），也可以有多个线程） 线程是os进行调度的最小单位。 进程是系统分配资源（包括CPU）的最小单位，线程是系统调度（CPU分配）的最小单位
【多线程】初步认识Thread类及其应用
acm_pn的博客
08-18 905
操作系统针对多个线程的执行，是一个“随机调度”，抢占式执行的过程。线程的调度执行是随机的，我们无法确定两个线程的调度顺序，但是可以控制谁先结束谁后结束。 线程等待就是确定两个线程的结束顺序，通过让后结束的线程等待先结束的线程执行，进入阻塞状态，直到先结束的线程执行完毕，此时阻塞解除，后结束的线程开始执行。这样就能使两个线程的结束顺序得以确定
Java多线程的初步认识
Yaphst的博客
05-18 396
在谈线程之前，我们至少应该了解下进程是什么，简单来说，进程就是正在运行的应用程序，每一个正在运行的应用程序就会对应一个进程。 那么线程，就是依赖于进程而存在的，一个进程可以开启多个线程，由一个对象所开启的所有线程使用的是同一份成员属性。 多线程的两种方案： 继承Thread类 实现Runable接口1.继承Thread类public class MyThre
初步了解多线程
Ddoze的博客
07-20 264
一、线程与进程的认识与联系 在生活中，我们打开qq、微信啊这些应用程序就相当于开启了一个进程。而当我们用这些软件中的功能，比如：看朋友圈、聊天、扫一扫等操作的时候。这些就相当于是进程了。 1.简单来说，进程：指在系统中正在运行的一个应用程序；一个程序可以执行多个任务（也就是线程）。它占独立的空间，每个进程保持各自运行状态，相互之间不会干扰，是并发执行的（并发指按先后顺序执行）。程序一旦运行就是进程；进程——资源分配的最小单位。 线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。
01认识多线程及其使用
好小伙
05-19 140
引出 并发/高并发 简单来说，并发是指单位时间内能够同时处理的请求数。默认情况下Tomcat可以支持的最大请求数是 150，也就是同时支持150个并发。当超过这个并发数的时候，就会开始导致响应延迟，连接丢失等问 题。 影响并发的两个因素: 硬件: CPU,内存,磁盘 网络 软件 线程数量 JVM内存分配大小 网络通讯机制(BIO,NIO,AIO) 磁盘IO Java中的线程 public class ThreadTest extends Thread{ @Override publ
7. 初步认识线程同步
十三阿哥的博客
01-26 342
初步认识线程同步的含义，通过一个实际案例去更好的认识线程同步。
java中对多线程的了解_关于java的多线程的初步认识
weixin_30836221的博客
02-27 117
进程：正在进行中的程序(直译). 线程：就是进程中一个负责程序执行的控制单元(执行路径) 一个进程中可以多执行路径，称之为多线程。一个进程中至少要有一个线程。开启多个线程是为了同时运行多部分代码。每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务。多线程好处：解决了多部分同时运行的问题。多线程的弊端：线程太多回到效率的降低。其实应用程序的执行都是cpu在做着快速的切换完成的。这个...
理解python多线程（python多线程简明教程）
01-20
所以，这里力图用简单的例子，让你对多线程有个初步的认识。 单线程 　在好些年前的MS-DOS时代，操作系统处理问题都是单任务的，我想做听音乐和看电影两件事儿，那么一定要先排一下顺序。 （好吧！我们不纠结在DOS...
python多线程就这么简单
01-27
所以，这里力图用简单的例子，让你对多线程有个初步的认识。在好些年前的MS-DOS时代，操作系统处理问题都是单任务的，我想做听音乐和看电影两件事儿，那么一定要先排一下顺序。（好吧！我们不纠结在DOS时代是否有听...
Linux多线程服务端编程：使用muduo C 网络库
03-30
通过阅读《Linux多线程服务端编程：使用muduo C++网络库》样章，读者可以对muduo库有一个初步的认识，并开始掌握如何在实际项目中应用这些技术。全书可能还涵盖了更多高级主题，如分布式系统、负载均衡、故障恢复等...
多线程&&进程&&开发板的初步认识
weixin_47423454的博客
04-12 282
一、多线程 1、线程 是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 2、多线程 2.1 安装pthread库 Ubuntu默认是没有pthread库的，需要安装。输入命令： sudo apt-get install -y glibc-doc manpages-posix-dev 2.2 创建线程 2.2.1创建线程与终止示例 （1...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 322
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 389
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 689
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
Java分布式锁
juanmiao的专栏
10-12 697
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 528
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
初步认识ThreadLocal
09-13
ThreadLocal是Java中的一个类，用于在多线程环境下为每个线程提供独立的变量副本。每个线程内部都有一个ThreadLocal.ThreadLocalMap属性，通过这个属性来实现存储和访问线程独立的变量副本。 通过ThreadLocal的set...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值