多线程

最新推荐文章于 2024-03-17 21:20:55 发布
最新推荐文章于 2024-03-17 21:20:55 发布
阅读量97 收藏
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52722789/article/details/114846557
版权

进程：

  1. 是程序的一次执行过程，有生命周期。
  2. 系统在运行时会为每个进程分配不同的内存区域

线程：

  1. 进程可进一步细化为线程，是一个程序内部的执行的路径
  2. 若一个进程同一时间并行执行多个线程，就是支持多线程的

分线程对象的创建线程：

方式一：继承Thread类

  1. 创建Thread类的子类
  2. 重写Thread类的run();将当前线程要执行的操作声明在run内()
  3. 实例化Thread类的子类（在main中）
  4. 通过Thread类的子类对象调用其start()；
    start()方法的作用
    启动进程
    调用当前线程的run()
  5. 主线程与分线程会争相去输出
public class Main {
	    public static void main(String[] args) {
	    	//3.实例化Thread类的子类
	    	Number num=new Number();
	    	//4.通过Thread类的子类对象调用其start();
	    	num.start();
	    }
  }
//1.创建Thread类的子类
class Number extends Thread{
	//2.重写run
	public void run() {
		//方法体
	}
}

说明：

  1. 分线程对象的创建和启动工作，是由主线完成的
  2. 一个线程只能够启动一次
  3. 分线程的执行顺序和代码先后出现的顺序无关，与CPU的资源调度有关
public class Main {
	    public static void main(String[] args) {
	    	//3.实例化Thread类的子类
	    	Number num=new Number();
	    	//4.通过Thread类的子类对象调用其start();
	    	num.start();
	    	Number num2=new Number();
	    	num2.start();
	    	
	    	结果不一定先输出num的线程
	    }
  }
//1.创建Thread类的子类
class Number extends Thread{
	//2.重写run
	public void run() {
		sout(Thread.currentThread().getName()+":"+i)//输出当前线程的名字
	}
}

方式二：实现Runnable接口的方式

  1. 提供Runnable接口的实现类
  2. 实现接口中的抽象方法：run()
  3. 创建实现类的对象
  4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
  5. 通过Thread类的对象调用start（）；
public class Main {
    public static void main(String[] args) {

          //3.c创建类的对象
        PrintNum print=new PrintNum();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的子类
        //由于Runable里没有start的方法，所以不能通过print.start()来启动线程
        Thread t=new Thread(print);
        //5.通过Thread类的对象调用start()
        t.start();
    }
}
//1.实现Runnable接口的实现类
class PrintNum implements Runnable{
    //2.重写run方法
    public void run(){
        for (int i=0;i<100;i++){
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

方式三：实现Callable接口

//例题：遍历100以内的偶数，并计算所有偶数的和

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
//  
//        
//      接收返回值
        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

方式四： 使用线程池的方式

//创建并使用多线程的第四种方法：使用线程池
//使用线程池创建多线程的好处：
//1.降低了资源的消耗，使用完的线程可以被复用。
//2.提高了程序的响应速度。
//3.便于管理。

class NumberThread implements Runnable{

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

class NumberThread1 implements Runnable{

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

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//        //设置线程池的属性
//        System.out.println(service.getClass());//ThreadPoolExecutor
        service1.setMaximumPoolSize(20);


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

问题：
为什么通过start（）调用的的是Thread类中的run（），此run（）怎么就表现为对Runnable实现类中的run（）的调用了呢？
解答：
在这里插入图片描述

线程安全（对于重票和错票）：

方式一：同步代码块

  1. 需要被同步的代码，即为操作共享数据的代码
    要求：包裹共享数据的代码，不能多不能少。
  2. 何为共享数据？多个线程的共同操作的数据。比如ticket。
  3. 同步监视器，俗称锁。任何一个类的对象，都可以充当同步监视器。
    要求：多个线程必须共用同一个同步监视器。
public class Main {
    public static void main(String[] args) {

        PrintNum print=new PrintNum();

        Thread t=new Thread(print);
        Thread t1=new Thread(print);
        Thread t2=new Thread(print);
        t.start();
    }
}
class PrintNum implements Runnable{
    private int ticket=100;
    Object obj=new Object();
    public void run(){
       while (true){
           synchronized (obj) {//obj为监视器
               if (ticket > 0) {
                   try {
                       Thread.sleep(100);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println(Thread.currentThread().getName() + "售票，票号为：" + ticket);
                   ticket--;
               }
           }
       }
    }
}

方式二：

如果操作共享数据的代码，完整的声明在方法中，则可以考虑将此方法直接声明为同步方法

  1. 说明：
    1.同步方法也有同步监视器，只不过是默认的同步监视器，不能显式定义
    2.对于非静态的同步方法，同步监视器是this
    3.对于静态的同步方法，同步监视器是当前类本身
public class Main {
    public static void main(String[] args) {

        PrintNum t=new PrintNum();
        PrintNum t1=new PrintNum();
        PrintNum t2=new PrintNum();

        t.start();
        t1.start();
        t2.start();
    }
}
class PrintNum extends Thread{
    private static int ticket=100;
    Object obj=new Object();
    public void run(){
       for (int i=1;i<=100;i++){
             show();
       }
    }
    public static synchronized void show(){
        if (ticket > 0) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "售票，票号为：" + ticket);
            ticket--;
        }
    }
}

方式三：

/*
 * 除了使用synchronized同步机制处理线程安全问题之外，还可以使用jdk5.0提供的Lock锁的方式
 * 
 * 一、步骤：
 * 1. 创建Lock实现类的对象：ReentrantLock （可重入锁） --->保证多个线程使用同一个Lock对象
 * 2. 调用Lock的方法：lock()。调用此方法的线程就可以操作共享数据。其他线程等待
 * 3. 在操作共享数据时，可以调用Lock的方法：unlock()。此方法一定要执行！
 * 
 * 二、面试题：synchronized 和 Lock方式的异同？
 *   相同点：解决线程的安全问题的两种不同方式。 synchronized在jdk1.0就有。 Lock在jdk5.0新增
 *   不同点：① Lock通过显式的调用unlock()结束对共享数据的操作，更灵活！② 在线程通信中，Lock搭配Condition使用更灵活。
 *   使用建议：参考Lock的api:
 *   Lock implementations provide more extensive locking 
 *   operations than can be obtained using synchronized methods 
 *    and statements
 */

2. 代码实现

public class WindowTest {
	public static void main(String[] args) {

		Window1 w = new Window1();

		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		Thread t3 = new Thread(w);

		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}

class Window1 implements Runnable {
	private int ticket = 100;
	//1.
	private final ReentrantLock lock = new ReentrantLock();
	@Override
	public void run() {
		while (true) {
			
			try {
				//2.
				lock.lock();
				if (ticket > 0) {

					try {
						Thread.sleep(30);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}

					System.out.println(Thread.currentThread().getName() + "售票，票号为:" + ticket);
					ticket--;
				} else {
					break;
				} 
			} finally {
				//3.
				lock.unlock();
			}
		}
	}
}

对比两种方式：

  1. 相同点
    都需要进行run（）方法的重写，但不是同一个run方法
    启动线程都需要调用Thread类中的start()方法
  2. 对比：方式二要好于方式一
    类可以实现多个接口，但是只能继承一个父类
    实现的方式更方便来处理共享数据的情况（因为不用加static，生命周期不那么长）
  3. 联系
    Thread类实现Runnable接口，所以Thread也重写了Runnable中的run（）方法

继承法操作同一个资源类的方法：

public class Main{
    public static void main(String[] args) {
        Customer customer=new Customer(1122,new Account());
        Thread t1=new Thread(customer);
        Thread t2=new Thread(customer);
        t1.start();
        t2.start();
    }
}
class Customer extends Thread{
    private int acc;
    private Account account;
    public Customer(int acc,Account account) {
        this.acc = acc;
        this.account=account;
    }

    @Override
    public void run() {
            for (int i=0;i<3;i++){
                account.addBanlancr();
        }
    }
}
class Account{
    private int balance=0;
    public synchronized void addBanlancr(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        balance+=1000;
        System.out.println(Thread.currentThread().getName()+"存了"+balance+"元");
    }
}

测试线程中的常用方法：

  1. start()：启动线程，调用线程中的run
  2. run()：将线程要执行的操作声明在此方法
  3. currentThread(): 获取执行当前代码的线程
  4. getName() :获取当前线程的名字
  5. setName(): 设置当前线程的名字,特殊的给主线程设置名字：Thread.currentThread().setName
  6. sleep(long milisecond): 使得一旦执行此方法，当前线程就阻塞指明的毫秒数
  7. yield(): 每当执行此方法时，线程主动释放cpu的执行权
  8. join(): 在线程a中调用线程b的join（）；此时线程a进入阻塞状态，知道线程b执行结束以后，才结束线程a的阻塞状态，线程a继续执行（即a线程暂停，执行b线程，知道b线程执行完毕，继续执行a线程）
  9. isAlive(): 判断线程是否存活，返回的是Boolean类型
十一.11
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
stm32单片机多线程实例
12-03
多线程是实现复杂任务并发执行的关键技术，能够提高资源利用率，优化系统响应时间。在STM32上实现多线程，通常会借助实时操作系统（RTOS）如RT-Thread。 RT-Thread是一个轻量级、开源的实时操作系统，它为STM32等微...
一文详解C++多线程
非晚非晚的博客
04-25 7万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
C++多线程详细讲解
qq_45439571的博客
03-19 4万+
本文是纯转载，觉得大佬写的非常好！如有侵权可以删除 链接: link. C++多线程基础教程 目录 1 什么是C++多线程？ 2 C++多线程基础知识 2.1 创建线程 2.2 互斥量使用 lock()与unlock(): lock_guard(): unique_lock: condition_variable: 2.3 异步线程 async与future： shared_future 2.4 原子类型automic 实例 生产者消费者问题 4 C++多线程高级知识 4.1 线程池 线程池基础知识 线程池
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程实战-CountDownLatch模拟压测实现
最新发布
qq_35716689的博客
03-17 16万+
当多个线程需要协调和同步执行任务时，Java 中的 CountDownLatch（倒计时器）是一个常用的工具类。它可以帮助开发者实现线程之间的同步，确保某些线程在其他线程完成任务后再继续执行。牵着猫散步的鼠鼠。本文将介绍 CountDownLatch 的基本原理、用法以及示例代码，最后会使用CountDownLatch完成一个简单的压测实现。
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Python多线程详解
千山暮彩
10-30 5万+
现代计算机CPU物理核心普遍比较多，我们在编写程序时经常会用到多线程技术来提高程序运行的效率。作为python萌新，我在掌握基本语法后就很想摆弄一下python的多线程，使用起来确实很有python的特点，代码量少、操作方便。之后断断续续写了一些多线程程序，直到今天下午逛论坛，看到很多人说python多线程机制的一些内情，我才意识到自己有多愚蠢哈哈。我把自己学到的内容系统的整理一下，以备后忘，也帮帮后来者。
多线程测试
09-21
在计算机科学领域，多线程是一种程序设计技术，它允许应用程序同时执行多个任务或子任务。这极大地提高了软件的效率和响应性，特别是在现代多核处理器的环境下。本主题将深入探讨多线程的实现方式及其与单线程的对比...
大漠多线程模板_大漠_大漠多线程_
09-30
"大漠多线程模板"是一个专门针对C#开发的多线程处理框架，它为开发者提供了便捷的方式来管理和优化多线程应用。这个框架由知名开发者"大漠"创建，旨在简化复杂的并发编程，提高代码的可读性和可维护性。 多线程允许...
安卓多线程
04-16
安卓多线程，安卓高级开发中，必备技能，项目开发中都要使用
多线程示例
03-30
在IT领域，多线程是程序设计中的一个重要概念，尤其在现代计算机系统中，它能够提升应用程序的效率和响应性。MFC（Microsoft Foundation Classes）是微软提供的一个C++类库，用于简化Windows应用程序的开发，包括...
qt websocket 客户端 多线程使用
09-16
qt 使用QWebSocket 创建websocket客户端来读取数据，异步链接，并且放入到线程中去执行，线程池的基础，代码使用两个用户，放入到一个线程中执行，同理，可以多个用户放入到多个线程中执行，为线程池执行websocket ...
WPF多线程实例
05-08
在Windows Presentation Foundation（WPF）开发中，多线程是一个重要的技术，特别是在处理大量数据或进行耗时操作时，为了保持用户界面（UI）的响应性，通常会使用多线程来实现非UI任务。本实例是关于如何在WPF应用...
多线程导入excel 数据
01-04
在Java编程中，多线程导入Excel数据是一项常见的任务，特别是在大数据处理和高并发场景下。这个场景通常涉及到性能优化和资源管理，以确保系统稳定性和数据一致性。下面将详细阐述多线程导入Excel数据的核心知识点。...
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值