JavaSE——多线程

最新推荐文章于 2024-07-12 15:51:39 发布
最新推荐文章于 2024-07-12 15:51:39 发布
阅读量77 收藏
点赞数
分类专栏： java基础篇 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Quiet_han/article/details/118034068
版权

文章目录

相关概念

并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）

进程和线程：进程是程序运行和资源分配的基本单位，一个程序至少有一个进程，一个进程至少有一个线程。进程在执行过程中拥有独立的内存单元，而多个线程共享内存资源，减少切换次数，从而效率更高。线程是进程的一个实体，是cpu调度和分派的基本单位，是比程序更小的能独立运行的基本单位。同一进程中的多个线程之间可以并发执行。

一、创建线程的两种方式

1.1 Thread类

Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

Java中通过继承Thread类来创建并启动多线程的步骤如下：

  1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把
    run()方法称为线程执行体。
  2. 创建Thread子类的实例，即创建了线程对象
  3. 调用线程对象的start()方法来启动该线程

自定义线程类：

//1.创建一个Thread类的子类
public class MyThread extends Thread{
    //在Thread类的族类中重写Thread类中的run方法，设置线程任务（开启线程要做什么）
    @Override
    public void run(){
        for(int i=0; i<20; i++){
            System.out.println("run:"+i);
        }
    }
}

测试类

public class Demo01Thread {
    public static void main(String[] args) {
        //3.创建Thread类的子类对象实例
        MyThread mt = new MyThread();
        //4.调用Thread类中的方法start(),开启新的线程,执行run方法
        mt.start();
        for(int i=0; i<20; i++){
            System.out.println("main线程:"+i);
        }
    }
}

1.2 Runnable接口

采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。
步骤如下：

  1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
  2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正 的线程对象。
  3. 调用线程对象的start()方法来启动线程。

步骤一：

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

步骤二三：

public class Demo { 
	public static void main(String[] args) { 
		//创建自定义类对象 线程任务对象 
		MyRunnable mr = new MyRunnable(); 
		//创建线程对象 
		Thread t = new Thread(mr, "小强"); 
		t.start(); for (int i = 0; i < 20; i++) { 
		System.out.println("旺财 " + i); 
		} 
	} 
}

1.3 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

总结： 实现Runnable接口比继承Thread类所具有的优势：

  1. 适合多个相同的程序代码的线程去共享同一个资源。
  2. 可以避免java中的单继承的局限性。
  3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
  4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

二、线程的五种状态

线程状态发生条件
New(新建)线程刚被创建，但是并未启动。还没调用start方法
Runnable(可运行)一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序来调度的。
Running(运行状态)当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法。
Blocked(锁阻塞)①线程通过调用sleep方法进入睡眠状态；②线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；③线程试图得到一个锁，而该锁正被其他线程持有；④线程在等待某个触发条件；所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。
dead(死亡状态)①run方法正常退出而自然死亡；②一个未捕获的异常终止了run方法而使线程猝死；为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法，如果是可运行或被阻塞，这个方法返回true；如果线程仍旧是new状态且不是可运行的，或者线程死亡了，则返回false。

三、线程安全

3.1 线程安全

什么是线程安全？
  当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在调用代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。


线程安全在三个方面的体现：
  原子性：提供互斥访问，同一时刻只能有一个线程对数据进行操作，（atomic,synchronized）；
  可见性：一个线程对主内存的修改可以及时地被其他线程看到，（synchronized,volatile）；
  有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序，该观察结果一般杂乱无序，（happens-before原则）。

3.2 线程安全实例

下面以一个实例来描述线程安全问题：
  假设来模拟电影院的售票窗口，实现多个窗口同时卖票，总票数100张，窗口使用线程对象来模拟，票使用Runnable接口来模拟；

模拟票：

public class Ticket implements Runnable {
    private int ticket = 100;
    /** 执行卖票操作 */
    @Override 
    public void run() {
        //每个窗口卖票的操作
        // 窗口 永远开启
        while (true) {
            if (ticket > 0) {
                //有票 可以卖，出票操作，使用sleep模拟一下出票时间
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto‐generated catch block
                    e.printStackTrace();
                    //
                   }
                //获取当前线程对象的名字
                String name = Thread.currentThread().getName();
                System.out.println(name + "正在卖:" + ticket--);
            }
        }
    }
}

测试类

public class Demo {
    public static void main(String[] args) {
        //创建线程任务对象
        Ticket ticket = new Ticket();
        //创建三个窗口对象
        Thread t1 = new Thread(ticket, "窗口1");
        Thread t2 = new Thread(ticket,"窗口2");
        Thread t3 = new Thread(ticket,"窗口3");

        //调用start方法，模拟同时卖票
        t1.start();
        t2.start();
        t3.start();
    }
}

来看运行结果：
在这里插入图片描述在这里插入图片描述

程序出现两个问题：
  1.相同的票号被卖了几次。
  2.不存在的票，比如0或者-1票，是不存在的。

上面这种问题，几个窗口(线程)票数不同步，被称为线程不安全，那下面来说说线程同步。

四、线程同步

根据上面的案例：
  窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码 去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU 资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

下面介绍三种方式完成同步操作。

4.1 同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。 格式:

synchronized(同步锁){
	需要同步操作的代码
}

底层实现原理：synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。Java中每一个对象都可以作为锁，这是synchronized实现同步的基础。锁对象的作用是把同步代码块锁住,只让一个线程在同步代码块中执行。
测试类与上面一样，修改模拟买票部分代码演示：

public class RunnableImpl implements Runnable{
    //定义一个多线程功共享票源
    private int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();

    //设置线程任务
    @Override
    public void run(){
        //使用死循环，让卖票操作重复执行
        while(true){
            //同步代码块
            synchronized (obj){
                //先判断票是否存在
                if(ticket>0){
                    //提高安全问题出现的概率，让程序睡眠
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //票存在，卖票
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                }
            }
        }
    }
}

4.2 同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。格式：

public synchronized void method(){
	可能会产生线程安全问题的代码
}

还是以卖票案例为基础，测试方法部分不变，代码演示：

public class Ticket implements Runnable {
    private int ticket = 100;

    /**
     * 执行卖票操作
     */
    @Override
    public void run() {
        //每个窗口卖票的操作 //窗口 永远开启
        while (true) {
            sellTicket();
        }
    }

    /**
     * 锁对象是谁调用这个方法就是谁
     * 隐含锁对象就是 this
     */
    public synchronized void sellTicket() {
        if (ticket > 0) {
            //有票可以卖, 出票操作, 使用sleep模拟一下出票时间
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto‐generated catch block
                e.printStackTrace();
            }
            //获取当前线程对象的名字
            String name = Thread.currentThread().getName();
            System.out.println(name+"正在卖"+ticket--);
        }
    }
}

4.3 Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：

  • public void lock() :加同步锁。
  • public void unlock() :释放同步锁。

使用步骤：

    1.在成员位置创建一个ReentrantLock对象
    2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
    3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

还是以卖票案例为基础，加上Lock锁，代码演示：

	public class RunnableImpl implements Runnable{
    //定义一个多线程功共享票源
    private int ticket = 100;

    //1.在成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();

    //设置线程任务
    @Override
    public void run(){
        //使用死循环，让卖票操作重复执行
        while(true){
            //2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
            l.lock();

            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                    //票存在，卖票
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
                    l.unlock();//无论程序是否异常,都会把锁释放
                }

            }
        }
    }
}

4.4 synchronized 和 Lock 有什么区别？

  • 首先synchronized是java内置关键字，在jvm层面，Lock是个java类；

  • synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；

  • synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；

  • 用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；

  • synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）；

  • Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

总结

有关多线程方面的知识就介绍找么多，大家可以了解一下。

Quiet_han
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE——多线程编程
weixin_42067873的博客
02-05 341
数据不同步问题解决 测试类中，有一个静态成员a，定义2000个子线程，分别执行对静态变量a的++操作，然后在主线程中输出累加后的a值 MyRunnable: public class MyRunnable implements Runnable{ Object lock = new Object(); @Override public void run() { synchronized (lock) { MyTest.a++; ..
JavaSE——多线程详细
weixin_51351637的博客
12-12 623
一个应用程序，一个进程就是一个软件：一个进程中的执行场景/执行单元对于java程序来说，当在DOS命令窗口中输入java HelloWorld回车之后，会先启动JVM，而JVM就是一个进程，JVM再启动一个主线程调用main方法，同时再启动一个垃圾回收线程负责看护，回收垃圾，也就是说java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。
javaSE——多线程
Demon_and_Angle_的博客
08-17 163
要启动多线程，就一定需要通过Thread类中的start()方法，但是Runnable接口中没有提供可以被继承的start()方法。优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)。线程的起点：start()。（线程的启动，启动后执行的方法体是run()方法定义的代码）Thread是操作线程的类，任何类只需要继承Thread类就可以成为一个线程的主类。所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。线程执行体：run()。程序的起点：main()。..
Javase——多线程
luo981695830的博客
09-29 283
多线程 程序：一段静态代码 进程：加载到内存中的正在运行中的程序，一个程序可以启动多个进程 线程：进程中子任务，线程间通信非常容易 java.lang.Thread类来表示 入口方法是run() 启动方法是start() 创建并启动线程的步骤 方式一：实现Runnable接口 写一个具体类，实现Runnable接口，重写run()方法 创建这个类的对象，将对象作为实...
javaSE——多线程基础
成长中的白嫖党
11-25 342
目录 进程和线程的定义、区别、组成 一、进程和线程的定义、区别 1. 定义： 2. 区别： 进程是操作系统资源分配的基本单位，线程是CPU的基本调度单位 一个程序运行后至少有一个进程 一个进程可以包含多个线程，但至少要有一个线程，不然该进程没有意义 进程间不能共享数据地址，但同个进程下的多个线程间可以共享。 3. 线程的组成： ③④⑤ 任何一个线程都具有基本的组成部分： –①CPU时间片：操作系统 （OS）为每个线程分配的执行时间 –②运行数据： ——堆空间：存储线程需要使用的对象，多个线程
Day23JavaSE——多线程&实现
adAir_liu的博客
06-16 467
Day23JavaSE——多线程&实现 文章目录Day23JavaSE——多线程&实现进程的概述和多进程的意义并行和并发的区别Java程序运行原理和JVM的启动是多线程的吗多线程实现方式一案例利用多线程复制文件线程优先级问题线程控制实现多线程方式二(解决了Java中只能单继承问题)实现多线程方式3卖电影票案例继承Thread类的方式卖电影票案例实现Runnable接口的方式卖电影票线程安全问题生产消费者线程案例同步代码块解决线程安全问题同步方法锁JVM内存模型JVM内存模型 多线程 进程
JavaSE——多线程：Lock体系
LiLiLiLaLa的博客
07-04 362
1.初识Lock与AbstractQueuedSynchronizer(AQS) 1.1.Lock简介 锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁能够防止多个线程同时访问共享资源。在Lock接口出现之前，java程序主要是靠synchronized关键字实现锁功能的，而JDK5之后，并发包中增加了lock接口，它提供了与synchronized一样的锁功能。虽然它失去了像synchr...
JavaSE——多线程：常用操作方法
LiLiLiLaLa的博客
06-29 222
1.多线程的常用操作方法 1.1.线程命名与取得 多线程的运行状态是不确定的，所以对于多线程操作必须有一个明确标识出线程对象的信息，这个信息往往通过名称来描述。在Thread类中提供有如下的线程名称获得相关方法： No. 方法名称 类型 描述 1 public Thread(Runnable target,String name) 构造 创建线程的时候设置名称 2 public...
JavaSE——多线程之基本概念及相关知识
weixin_42223645的博客
12-25 106
一、基本概念：程序、进程、线程 程序是为了完成特定任务、用某种语言编写的一组指令的集合。即一段静态的代码。 进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程，即生命周期。 如：运行中的QQ、运行中的MP3播放器 >程序是静态的，进程是动态的。 >...
javase之多线程技术
10-16
Java中的多线程技术是Java进阶学习的重要组成部分，它涉及到并发编程的理论与实践，旨在提高程序的执行效率和响应速度。以下是对多线程技术的详细解释： 1. **CPU调度算法原理** - **先来先服务（FCFS）**：按照...
JavaSE实战——客户端上传文件到服务端
05-05
4. **多线程**：在服务端，通常会用到多线程技术，因为服务器可能同时处理多个客户端的请求。每个客户端的Socket连接都可以看作一个独立的任务，我们可以创建一个ServerSocket监听客户端连接，每当有新的连接到来，...
JavaSE实战——GUIChat
05-05
10. **多线程**：考虑到GUI的响应性和网络通信的异步性，GUIChat可能使用了多线程。主线程用于处理GUI更新，而网络通信则在单独的线程中执行，避免了因网络延迟导致的界面冻结。 总的来说，GUIChat项目是Java SE...
JavaSE.xmind
07-10
案例 + 知识点：其中包括了方法，数组，继承多态封装，基本数据类型与引用数据类型；super关键字，方法的重载，构造方法的重载，排序（冒泡排序、选择排序、JDK排序案例）并对各个知识点进行了相应的案例进行分析。
大三上学期JavaSE期中考试
10-21
在大三上学期的JavaSE期中考试中，学生可能会面临一个实际的项目——汽车租赁系统。这个系统是基于Java编程语言实现的，主要目的是为了模拟真实的商业场景，让学生掌握JavaSE的基础知识并能将其应用到实际问题解决中...
配置Java开发环境
Broken_x的博客
07-10 1461
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 351
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 427
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2324
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
JavaSE专题-多线程总结.doc
06-03
多线程的常见问题总结分析 1、多线程技术介绍 2、主线程介绍 3、创建线程的方式 4、线程中的异常问题 5、线程运行状态 6、线程第二种创建方式 7、多线程练习 8、线程安全问题分析和解决 9、多线程细节 10、同步使用的锁

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值