Java基础——多线程

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量172 收藏 1
点赞数
分类专栏： java基础 文章标签： 多线程 java 多进程 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Arrake/article/details/109957461
版权

文章目录

一、基本概念：程序、进程、线程

程序：一段静态代码

进程：一个正在执行的程序

线程：一个程序内部的一条执行路径（一大段代码分成一份或几份代码执行，它是其中一份）

在这里插入图片描述

并行：多线程执行多个任务，每个任务之间独立，互不干扰

并发：多线程执行一个任务

二、线程的创建和使用

线程默认优先级

MAX_PRIORITY：10

MIN _PRIORITY：1

NORM_PRIORITY：5

涉及的方法

getPriority() ：返回线程优先值

setPriority(intnewPriority) ：改变线程的优先级

Thread类相关方法

void start(): 启动线程，并执行对象的run()方法

run(): 线程在被调度时执行的操作

String getName(): 返回线程的名称

void setName(String name):设置该线程名称

static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类

static void yield()：线程让步

暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程

若队列中没有同优先级的线程，忽略此方法

join()：当某个程序执行流中调用其他线程的join() 方法时，调用线程将被阻塞，直到join() 方法加入的join 线程执行完为止

低优先级的线程也可以获得执行

static void sleep(long millis)：(指定时间:毫秒)令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队，进入阻塞状态。

抛出InterruptedException异常

线程的分类

Java中的线程分为两类：一种是守护线程，一种是用户线程。

它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。

守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。

Java垃圾回收就是一个典型的守护线程

若JVM中都是守护线程，当前JVM将退出

1.继承Thread类

public class ThreadTest01 {
    public static void main(String[] args) {
        //3.创建那个类的对象
        ThreadTest threadTest01 = new ThreadTest();
        ThreadTest threadTest02 = new ThreadTest();
        //通过调用该对象的start方法去启动线程
        threadTest01.start();
        threadTest02.start();
    }
}
//1.创建一个继承Thread类的类
class ThreadTest extends Thread {
    //2.重写Thread的run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

2.实现Runnable接口

①一般实现

public class ThreadTest02 {
    public static void main(String[] args) {
        //3.创建那个实现Runnable接口的类的对象
        RunnableTest runnableTest = new RunnableTest();
        //4.通过Thread的类去创建一个线程
        Thread thread01 = new Thread(runnableTest);
        Thread thread02 = new Thread(runnableTest);
        //5.通过start调用线程
        thread01.start();
        thread02.start();
    }
}
//1.创建一个实现Runnable接口的类
class RunnableTest implements Runnable {
    //2.实现Runnable的run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

②匿名内部类实现

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

③lambda表达式实现

new Thread(()-> System.out.println(Thread.currentThread().getName())).start();

3.实现Callable接口（jdk5.0新增）

创建线程的方式三：实现Callable接口。 --- JDK 5.0新增
如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
1. call()可以有返回值的。
2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
3. Callable是支持泛型的

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadTest04 {
    public static void main(String[] args) {
        //3.
        CallableTest callableTest = new CallableTest();
        //4.
        FutureTask futureTask = new FutureTask(callableTest);
        //5.
        new Thread(futureTask).start();
        try {
            Object o = futureTask.get();
            System.out.println(o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//1.
class CallableTest implements Callable {
    //2.
    @Override
    public Object call() throws Exception {
        int num = 0;
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            num += i;
        }
        return num;
    }
}

4.线程池创建（jdk5.0新增）

创建线程的方式四：使用线程池
好处：
1.提高响应速度（减少了创建新线程的时间）
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3.便于线程管理
     corePoolSize：核心池的大小
     maximumPoolSize：最大线程数
     keepAliveTime：线程没有任务时最多保持多长时间后会终止

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class ThreadTest05 {
    public static void main(String[] args) {
        //2.
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service01 = (ThreadPoolExecutor) service;
        //3.
        service.execute(new ThreadTool01());
        service.execute(new ThreadTool02());
        //4.
        service.shutdown();
    }
}
//1.
class ThreadTool01 implements Runnable {

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

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

三、线程的生命周期

在这里插入图片描述

四、线程的同步

问题的提出

模拟火车站售票程序，开启三个窗口售票。

public class ThreadTest06 {
    public static void main(String[] args) {
        //多核多线程的电脑，跑不出-1，0，因为第一个sleep线程醒来还没print了还没--第二个线程就print了，是真多线程在跑
        //打印同时ticket-- 和 换行ticket--从结果上看效率明显不一样，因为 打印同时ticket--永远看不到第三次打印1
        Runnable windows = new Runnable() {
            private int tickets = 100;

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (tickets > 0) {
                        System.out.println(Thread.currentThread().getName() + ":" + tickets);
                        tickets--;
                    }else {
                        break;
                    }
                }
            }
        };
        Thread thread01 = new Thread(windows);
        Thread thread02 = new Thread(windows);
        Thread thread03 = new Thread(windows);
        thread01.start();
        thread02.start();
        thread03.start();
    }
}

线程同步的机制

让一个线程进入执行，其他不能进入执行，直到这个线程执行完

优点：解决线程安全问题

缺点：效率低

1.同步代码块（synchronized）

synchronized(同步监视器){
	//代码
}

同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。要求：多个线程必须要共用同一把锁。

保证唯一的有，任一Class对象

2.同步方法

public synchronized void show (String name){ ....}

自动释放锁的操作

1.当前线程的同步方法、同步代码块执行结束

2.当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。

3.当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。

4.当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

不会释放锁的操作

1.线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行

2.线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。

3.锁（Lock，jdk5.0新增）

import java.util.concurrent.locks.ReentrantLock;

public class ThreadTest07 {
    public static void main(String[] args) {
        Runnable windows = new Runnable() {
            private int tickets = 100;
            private ReentrantLock lock = new ReentrantLock();

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    lock.lock();
                    try {
                        if (tickets > 0) {
                            System.out.println(Thread.currentThread().getName() + ":" + tickets);
                            tickets--;
                        }else {
                            break;
                        }
                    } finally {
                    lock.unlock();
                    }

                }
            }
        };
        Thread thread01 = new Thread(windows);
        Thread thread02 = new Thread(windows);
        Thread thread03 = new Thread(windows);
        thread01.start();
        thread02.start();
        thread03.start();
    }
}

synchronized与lock的区别？

相同：对可以解决线程安全问题

不同：

1.synchronized自动释放锁，lock手动

2.lock只能作用代码块，synchronized代码块和方法

五、线程的通信

wait() 与notify() 和notifyAll()

wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行

调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等

notifyAll()：唤醒正在排队等待资源的所有线程结束等待

问题

1.使用Runnable创建线程时，Thread类是如何调用它的run方法的？

调用构造参数时，run方法内部调用了实现Runnable类的run方法
在这里插入图片描述
在这里插入图片描述

面试题

一、sleep()和wait()方法的区别？

1.sleep的定义是在Thread类中，wait的定义是Object类中

2.wait会释放锁，sleep不会

二、请说出你所知道的线程同步的方法

1.同步代码块

2.同步方法

3.jdk5.0新增锁类

Arrake
关注
专栏目录
Java——多线程编程技术.pdf
12-31
"Java多线程编程技术.pdf" Java多线程编程技术是Java平台的一个重要技术优势，是第一个直接把跨平台线程模型和标准的内存模型集成到语言中的主流语言。多线程编程技术是Java平台的一个重要技术优势，它可以使程序的...
Java练手小项目——多线程聊天室.zip
01-14
【Java练手小项目——多线程聊天室】 在Java编程世界中，多线程是不可或缺的一部分，尤其在开发实时性、交互性强的应用时，如我们的主题“多线程聊天室”。这个实战项目旨在帮助开发者深入理解Java多线程的概念，并...
多线程练习
TU_BO的博客
12-05 757
一、判断题(T为正确,F为错误),每题1分 1.如果线程死亡，它便不能运行。（T） 2.在Java中，高优先级的可运行线程会抢占低优先级线程。（F ） 3.线程可以用yield方法使低优先级的线程运行。（Y） 4…程序开发者必须创建一个线程去管理内存的分配。（T） 5.一个线程在调用它的start方法，之前，该线程将一直处于出生期。（ F） 6.当调用一个正在进行线程的stop( )方法
Java---多线程基础总结
ainstinct的博客
05-21 289
Java基础—多线程 一、基本概念 1.程序：指为完成特定任务编写的一组指令的集合。 2.进程：程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：自身的产生–存在–消亡—生命周期。 3.线程：指程序内部的一条执行路径；若一个进程同一时间并行执行多个线程，就是支持多线程的（多个线程共享内存区域的方法区和堆）；线程是调度和执行的最小单位，每个线程拥有独立的运行栈和程序计数器（pc)。 4.并行和并发： 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。 并发：一个CPU（采用时间片）同时
多线程编程：编写一个图形界面程序，让其中有一个线程能在界面上“实时” 显示系统当前时间， 另让一个线程可以在界面上提示当前系统时间下，用户改干什么
zy_li233的博客
04-22 1631
题目： 多线程编程题目 2：编写一个图形界面程序，运行之后，让其中有一个线程能在界面上“实时” 显示系统当前时间（精确到秒获取时间可查询 java.util.Calendar 类，它包含了多个用于获得系统时间 的函数） 。另让一个线程可以在界面上提示当前系统时间下用户该做什么工作（例如当程序判断出系统时 间现在是 8：00 到 9：00，则提示用户该上课；现在是 23：00 到 8：00，则提示用...
多线程练习题
OceanStar的博客
07-14 1607
判断题 1.C 和 Java 都是多线程语言。（ ×） c是单线程语言 2.如果线程死亡，它便不能运行。（ √） 3.在 Java 中，高优先级的可运行线程会抢占低优先级线程。（ √） 4.程序开发者必须创建一个线程去管理内存的分配。（× ） java提供了一个系统线程来管理内存的分配 5.一个线程在调用它的start方法之前，该线程一直处于出生期。（√ ） 6.当调用一个正在进行线程的 stop()方法时，该线程便会进入休眠状态。（× ） 线程死亡 7.如果线程的 run 方法执行结束或抛出一
java基础——多线程
wbcra的博客
06-14 2987
并发与并行 l并行:指两个或多个事件在同一时刻发生(同时发生)。 l并发:指两个或多个事件在同一个时间段内发生。
超详细JAVA基础——多线程
热门推荐
qq_45781655的博客
04-12 2万+
学会Java多线程，只看一个博客就够了！
黑马程序员——java基础——多线程的学习总结
黑马程序员——ItBin2015的博客
07-21 2803
android培训、java培训期待与您交流！ 进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元(线程就是进程的一个执行路径)。线程在控制着进程的执行。 多线程则扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务。线程(Thread )也被称作轻量级进程(Lightweight Proc
JAVA面试题——多线程.docx
06-12
### JAVA面试题——多线程知识点详解 #### 一、线程与进程的基本概念 线程和进程是并发编程中的两个基本概念。进程是操作系统进行资源分配和调度的基本单位，而线程则是进程中的实际运行单元。每一个进程都有其...
java—通过使用同步方法解决实现Runnable接口的方式的线程安全问题
yulingzheng的博客
04-21 239
通过使用同步方法解决实现Runnable接口的方式的线程安全问题 class Window3 implements Runnable{ private int Ticket =20;//多个线程共用一个Ticket Object object = new Object(); public void run() { while (true) { sh...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 417
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 526
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 793
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1231
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 322
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1108
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值