java线程基础

于 2024-09-19 20:58:15 发布
阅读量968 收藏 19
点赞数 13
分类专栏： java 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80658524/article/details/142369614
版权

一.多线程

a.大致内容

1.进程:在内存中执行的应用程序
2.线程:是进程中最小执行单元
线程作用:负责当前进程中程序的运行，一个进程至少有一个线程,一个进程中还可以有多个线程，简称：多线程

在这里插入图片描述

3.使用场景

软件中耗时操作->拷贝大文件，加载大量资源

所有聊天

后台服务器

一个线程可以干一件事，我们就可以同时干多件事，提高cpu利用率

b.并发和并行

1.并行：在同一时刻，有多个执行在多个cpu上同时惊进行

2.并发：在同一时刻，有多个指令在单个cpu上交替执行

detail：

1.之前cpu是单核的，但是执行多个程序的时候好像是在同时执行，原因是cpu在多个线程之间做高速切换

2.现在cpu是多核多线程的了，比如2核4线程，cpu可以同时运行4个线程，多了就要切换，所以现在cpu执行并发和并行都存在

c.CPU调度

1.分时调度：指的是让每个线程轮流获取cpu使用权，并且平均分配每个线程占用cpu的时间片
2.抢占模式多个线程轮流抢cpu使用权，优先级高抢到几率大，java用的这种

d.实现thread

1.extends Thread

1.定义一个类，继承tread
2.重写run方法设置线程任务（具体干的事，执行代码）
3.创建自定义线程类对象
4.调用tread中的start方法，开启线程

java

package tread_class;

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



java
package tread_class;
public class test01 {
    public static void main(String[] args) {
        //创建线程对象
        thread thread = new thread();
        //调用start

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

e.运行原理

在这里插入图片描述

f.常用方法

run()->设置线程任务
getname()->获取线程名字
setname()->设置名字
currentThread()->获取正在执行的线程对象
sleep()->线程睡眠,超时后自动醒来

	java
	package tread_class;

public class thread01 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            //sleep睡觉
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(i);
        }
    }
}


java
package tread_class;

public class test02 {
    public static void main(String[] args) {
        thread01 thread01 = new thread01();
        //设置名字
        thread01.setName("111");
        thread01.start();
        //获取
        System.out.println(thread01.getName());
        for (int i = 0; i <10 ; i++) {
            //获取当前线程
            System.out.println(Thread.currentThread().getName()+i);

        }
    }
}

问题：为啥在重写的run方法中有异常只能try不能throws
原因：继承的thread中的run方法中没有抛异常，所以子类重写后不能抛只能try

g.其他方法

setPriority(int newPriority)->设置线程优先级，不是一定是最先抢到的，提高几率
gettPriority->获取优先级
setDeamon()->守护线程->当非守护线程执行完毕，守护线程就要结束，但是守护线程也不会立马结束，系统返回需要时间
yield()->礼让线程
join()->插队线程，插入某线程之前

java
package mythread;

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


java
package mythread;

public class test01 {
    public static void main(String[] args) {
        thread_02 thread02 = new thread_02();
        thread02.setName("t1");
        thread_02 thread03 = new thread_02();
        thread03.setName("t2");
        System.out.println(thread02.getPriority());
        System.out.println(thread03.getPriority());
        thread03.setPriority(1);
        thread02.setPriority(10);
        thread03.start();
        thread02.start();
    }
}

java
package mythread.protest;

public class mythread02 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(currentThread().getName()+"/"+i);
        }
    }
}
package mythread.protest;

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

        }
    }
}
package mythread.protest;

public class mythread02 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(currentThread().getName()+"/"+i);
        }
    }
}

g.1第二种方式实现Runnable接口

1.创建类实现runnabe接口

java
package mythread.runnable;

public class myrunable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"......"+i);
        }
    }
}


2.重写run方法，设置线程任务
3.利用thread构造方法:Thread(Runnable target)

java
package mythread.runnable;

public class Test01 {
    public static void main(String[] args) {
        myrunable myrunable = new myrunable();
        Thread t1=new Thread(myrunable);
        t1.start();
    }
}


4.调用start

f两种线程区别

	继承只支持单继承
	Runnable:没有继承局限性，可以多继承

h匿名内部类创建多线程

	匿名内部类回顾
	1.new接口()/抽象类()
	{
	重写方法
	}.重写方法（）；
	2.接口名/类名 对象名=new 接口/抽象类(){
	重写方法
	}
	对象名.方法();

java
public class test01 {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for (int i=0;i<10;i++)
                {
                    System.out.println(Thread.currentThread().getName()+i);
                }
            }
        }.start();

    }
}

m安全

在这里插入图片描述

java
public class mytickt implements Runnable{
    int tickt=100;
    @Override
    public void run() {
        while (true) {
            if (tickt > 0) {
                System.out.println(Thread.currentThread().getName() + "买到票了" + tickt + "票");
                tickt--;
            }
        }
    }

}
public class Test02 {
    public static void main(String[] args) {
        mytickt mytickt = new mytickt();
        Thread t1=new Thread(mytickt,"赵四");
        Thread t2=new Thread(mytickt,"张三");
        Thread t3=new Thread(mytickt,"王五");
        t1.start();
        t2.start();
        t3.start();
    }
}
解决方法一（上锁）(使用同步代码块)
  • 1.格式
    • synchronized(任意对象){
      线程可能出现不安全}
  • 2.任意对象：即是锁对象
  • 3.执行:
    • 抢到锁就执行，没有就等待
    

java

package mythread.change_security;

public class  mytickt implements Runnable{
    int tickt=100;
    //任意new一个对象
    Object obj =new Object();
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (obj)
            {
            if (tickt > 0) {
                System.out.println(Thread.currentThread().getName() + "买到票了" + tickt + "票");
                tickt--;
            }
        }
        }
    }

}
public class Test02 {
    public static void main(String[] args) {
        mytickt mytickt = new mytickt();
        Thread t1=new Thread(mytickt,"张三");
        Thread t2=new Thread(mytickt,"赵四");
        Thread t3=new Thread(mytickt,"王五");
        t1.start();
        t2.start();
        t3.start();
    }
}
解决方法二
非静态
  •   在Runnale接口类中写一个单独的方法

  •   默认锁对象是this

java
package mythread.change_security;
public class  mytickt implements Runnable{
    static int tickt=100;
    //任意new一个对象
    Object obj =new Object();
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        method();
        }
    }
    public static void method()
    {
        if (tickt > 0) {
            System.out.println(Thread.currentThread().getName() + "买到票了" + tickt + "票");
            tickt--;
        }
    }
    

}
静态
1.格式：
修饰符 static synchronized 返回值类型 方法名(参数){
	方法体
}
return 结果
2.默认值:class对象

h死锁

在这里插入图片描述

静态
1.格式：
修饰符 static synchronized 返回值类型 方法名(参数){
	方法体
}
return 结果
2.默认值:class对象

g生命周期

1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
  1. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
    线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
  2. 阻塞(BLOCKED)：表示线程阻塞于锁。
  3. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
  4. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
  5. 终止(TERMINATED)：表示该线程已经执行完毕。
    ————————————————

原文链接：更多请点击

慕情长
关注
专栏目录
Java线程基础教程完整版
03-14
通过深入学习和实践这些Java线程基础知识，你可以有效地编写出高效、安全的多线程程序。记住，理解线程的原理和掌握同步机制是关键，这将有助于解决复杂的并发问题。阅读"Java线程.pdf"文档，你将获得更详细、全面的...
java中的多线程1.基础知识
zb_andy_j的博客
09-10 218
线程 1.进程和线程的区别 进程是计算机分配资源的最小单元。每个进程的内存空间是相互独立的。 线程是计算机执行调度的最小单元。进程下的线程共用改进程的内存空间。 2.创建以及启动线程 继承Thead public class Create01 extends Thread { @Override public void run() { System.out.println("XXX extends Thread"); } public static void main(Stri
关于JAVA中的线程池
weixin_59937976的博客
10-09 497
java中有四种线程池： 一，缓存线程池： 1，判断有无空闲的进程； 2，存在则使用线程； 3，不存在则重新新增线程放入线程池，线程池无限制大小，并使用该线程； ExecutorService service = Executors.newCachedThreadPool(); //向线程池中 加入 新的任务 service.execute(new Runnable() { @Override public void run(...
java四大线程池
weixin_42481364的博客
09-03 667
线程池的好处 降低资源消耗、提高响应速度、提高线程的可管理性。 缓存线程池CahcedThreadPool 长度无限制。 执行流程： 判断线程池是否存在空闲线程。 存在则使用。 不存在，则创建线程，放入线程池，然后使用。 定长线程池FixedThreadPool 长度是指定数值 任务加入后的执行流程： 判断线程池是否存在空闲线程。 存在则使用。 不存在空闲线程，且线程池未满的情况下，则创建线程并放入线程池，然后使用。 不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程。
基于线程池ThreadPoolExecutor参数的大致理解
ggbyyds的博客
04-27 297
基于ThreadPoolExecutor 的参数大致理解
线程池笔记
金牛区代码仔的博客
08-05 330
shutdown()：遍历workers，调用tryLock()判断线程是否空闲，是空闲，则调用interrupt()方法中断线程。shutdownNow()：不会调用tryLock()，而是直接调用interruptWorkers();tryLock()方法核心也是cas操作，尝试将线程的状态变量从0变成1，操作成功返回true，失败返回false。步骤⼀：判断当前线程数是否⼤于或等于corePoolSize。调用其tryLock()方法，如果没获取到锁，表示线程在忙，如果获取到了锁，表示线程是空闲的。.
java-thread：Java线程基础信息
02-07
Java线程基础信息 java线程操作机制 java线程运行机制 通过芯片的速度越来越快，散热也越来越困难。很久都没有看到CPU的原始速度有重大提升了。但我们仍然看到摩尔定律在起作用，CPU的设计者们继续在向每片硅晶上...
Java线程基础
12-28
java多线程基础（英文），本文包括线程基础，生命周期，数据访问，线程同步等内容.
Java线程基础知识
03-11
总结来说，Java线程基础知识涵盖的内容丰富，从线程的基本概念，到线程在程序中的应用，再到线程间的通信和同步机制，都是多线程编程中不可或缺的一部分。掌握这些知识对于开发高性能、多任务并行处理的应用程序具有...
【速看】一招教你快速如何快速确定线程池的线程数
唐欢
09-15 1514
线程池标准创建方式是通过标准构造器ThreadPoolExecutor去构造工作线程池。那么corePoolSize和maximumPoolSize 的该如何设置呢？在设置这两个值之前，首先需要通过任务类型对线程池进行分类， 可以分为IO密集型任务，CPU 密集型任务和混合型任务。
Java多线程 - 如何确定线程池的线程数？
你今天真好看呀
03-09 1922
问题： 1、高并发、任务执行时间短的业务怎样使用线程池？ 2、并发不高、任务执行时间长的业务怎样使用线程池？ 3、并发高、业务执行时间长的业务怎样使用线程池？ 使用标准构造器ThreadPoolExecutor创建线程池时，会涉及线程数的配置，而线程数的配置与异步任务类型是分不开的。这里将线程池的异步任务大致分为以下三类： （1）IO密集型任务 此类任务主要是执行IO操作。由于执行IO操作的时间较长，导致CPU的利用率不高，这类任务CPU常处于空闲状态。Netty的IO读写操作为此类任务的典型例子。 由
1.线程系列- 线程的基本操作
qq_32062699的博客
10-30 506
新建线程 新建线程很简单，只需要使用new关键字创建一个线程对象，然后调用它的start()启动线程即可。 Thread t1 = new Thread(); t1.start(); 那么线程start()之后，会干什么呢？线程有个run()方法，start()会创建一个新的线程并让这个线程执行run()方法。 这里需要主要，下面代码也能通过编译，也能正常执行。但是，却不能新建一个线程，而是在当前线程中调用run()方法，将run方法作为一个普通的方法进行调用。 Thread t1 = new Threa
Java多线程 | 操作线程的方法详解
最新发布
devops
08-05 514
操作线程的常用方法详解
如何查看进程的线程数？
热门推荐
zhangwu416826的专栏
01-09 1万+
之前因为线程内出现异常导致Python部分线程退出，程序以单线程方式运行了好几个星期，浪费了很多时间。 如何查看当前进程有多少个存活线程呢？ 方法1）pstree -p 4761（进程ID）。如下截图所示：   方法2）cat /proc/4761（进程ID）/status。如下图所示：     方法3）top -p 4761（进程ID），
java线程基础入门
12-17
java 线程基础入门 一个关于计算机的简化的视图是：它有一个执行计算的处理机、包含处理机所执行的程序的ROM(只读存储器)、包含程序所要操作的数据的RAM(只读存储器)。在这个简化视图中，只能执行一个作业。一个...
Java线程安全基础概念解析
08-29
Java线程安全基础概念解析 Java线程安全基础概念解析是Java编程语言中一个非常重要的概念，涉及到多线程编程、同步控制、线程安全等方面。了解Java线程安全基础概念可以帮助开发者编写更加高效、可靠的多线程程序。...
关于多线程你应该需要知道的事
sly_7031的博客
05-12 215
关于多线程你应该需要知道的事 为什么要使用多线程 既然所有的多线程代码都可以用单线程来实现，为何还要多线程？ 提高CPU的利用率，提升程序处理能力 计算机多核多线程时代的来临，意味着，同一时刻，计算机可以干两件事！ 有一些业务场景的实现，用多线程实现更容易，并且更贴切实际 同一个进程中：生产者、消费者 两个人在打游戏，同时扔出一个大招 不要让后来的任务等待太久，大家平均点(用户请求) 我们一直在用的多线程 用户同时访问网站，我们Java服务用servlet进行处理。对于每个用户请求，都是用一个独立的线程来处
线程池的解析以及7个参数
好好玩的博客
03-30 5644
文章目录1.线程池的七个参数2.线程池的执行流程3.线程池的属性标识3.1、 核心属性3.2、线程池状态变化4.线程池的execute()方法执行4.1、execute()4.2、addWorker() 1.线程池的七个参数 1、corePoolSize： 核心线程数 2、maximumPoolSize： 最大线程数 3、keepAliveTime： 最大空闲时间 4、TimeUnit unit： 时间单位 5、BlockingQueue workQueue： 阻塞队列 6、ThreadFactory th
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值