多线程与并发

最新推荐文章于 2024-10-09 15:15:49 发布
置顶 最新推荐文章于 2024-10-09 15:15:49 发布
阅读量201 收藏
点赞数 1
分类专栏： web开发 文章标签： 多线程 同步、并发 死锁 单例模式 生产者及消费者
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40672583/article/details/90696859
版权

一、什么是进程、线程以及两者的关系

  • 进程 (Process)： 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。(引用自百度百科)
        进程的概念主要有两点：
        第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。
        第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为进程。
        在我们的电脑任务管理器中可以看到如下图所示的就是进程：
    如图所示就是我们电脑上运行的进程，可以看到我们的开发工具eclipse就是一个进程

  • 线程(Thread)：是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。线程共享进程资源。

二、线程的创建方式

1. 继承(extends)

    继承Thread并重写run()方法，如下代码所示：

/**
 * <p>Title:MyThread</p>
 * <p>Description:创建线程之继承</p>
 * @author XuelinR
 * @date 2019年5月30日
 *
 */
class MyThread extends Thread {
    /* (non-Javadoc)
     * <p>Title:run</p>
     * <p>Description:线程体中写要实现的业务逻辑</p>
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {
        System.out.println("我是线程体。");
    }
}
2. 实现(implements)

    这种方式是实现创建线程的接口，有两种方式：

a.实现Runnable接口
/**
 * <p>Title:TestThread</p>
 * <p>Description:实现接口Runnable</p>
 * @author XuelinR
 * @date 2019年5月30日
 *
 */
class MyThread implements Runnable {

    /* (non-Javadoc)
     * <p>Title:run</p>
     * <p>Description:</p>
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
        System.out.println("我是线程体。");
    }
    
}
b.实现Callable接口，此方式创建线程会有返回值
/**
 * <p>Title:MyThread</p>
 * <p>Description:实现Callable接口，有返回值</p>
 * @author XuelinR
 * @date 2019年5月30日
 *
 */
class MyThread implements Callable<String>{
    /* (non-Javadoc)
     * <p>Title:call</p>
     * <p>Description:</p>
     * @see java.util.concurrent.Callable#call()
     */
    @Override
    public String call() throws Exception {
        System.out.println("我是线程体。");
        return null;
    }
    
}

三、线程的状态

  • 线程从创建到结束的生命周期中包含了以下状态：
    线程的生命周期
  • 下图包含了创建、就绪、阻塞、运行等各阶段的运行方式
    线程的状态

四、线程的应用

1、线程的启动（静态代理）
  • 继承Thread时线程启动：
MyThread mt = new MyThread();
mt.start();
  • 实现Runnable时线程启动：
//实际类
TestThread tt = new TestThread();
//代理类，利用了代理类中的start方法
Thread proxy = new Thread(tt);
proxy.start();
2、线程池管理多线程
  • 一个有意思的故事：模拟龟兔赛跑
/**
 * <p>Title:Race</p>
 * <p>Description:比赛类</p>
 * @author XuelinR
 * @date 2019年5月30日
 *
 */
class Race implements Callable<Integer>{
    private String name;//名称
    private long time;//用时
    private Boolean flag = true;//控制循环
    private int step = 0;//步数
    public Race() {
    }

    /**
     * @param name
     */
    public Race(String name) {
        super();
        this.name = name;
    }

    /**
     * @param name
     * @param time
     */
    public Race(String name, long time) {
        super();
        this.name = name;
        this.time = time;
    }

    /* (non-Javadoc)
     * <p>Title:call</p>
     * <p>Description:线程体，步数递增</p>
     * @see java.util.concurrent.Callable#call()
     */
    @Override
    public Integer call() throws Exception {
        while (flag) {
           Thread.sleep(time);
           step++;
        }
        return step;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the time
     */
    public long getTime() {
        return time;
    }

    /**
     * @param time the time to set
     */
    public void setTime(long time) {
        this.time = time;
    }

    /**
     * @return the flag
     */
    public Boolean getFlag() {
        return flag;
    }

    /**
     * @param flag the flag to set
     */
    public void setFlag(Boolean flag) {
        this.flag = flag;
    }

    /**
     * @return the step
     */
    public int getStep() {
        return step;
    }

    /**
     * @param step the step to set
     */
    public void setStep(int step) {
        this.step = step;
    }
    
}

main方法中测试

 public static void main(String[] args) 
 	throws InterruptedException, ExecutionException {
        //调用线程池创建两个线程
        ExecutorService executor = Executors.newFixedThreadPool(2);
        Race tortoise = new Race("千年乌龟",1000);
        Race rabbit = new Race("小兔子",500);
        //获取值
        Future<Integer> r1 = executor.submit(tortoise);
        Future<Integer> r2 = executor.submit(rabbit);
        Thread.sleep(2000);
        //停止循环
        tortoise.setFlag(false);
        rabbit.setFlag(false);
        //获取返回步数
        int num1 = r1.get();
        int num2 = r2.get();
        System.out.println("千年乌龟跑了<"+num1+">步");
        System.out.println("小兔子跑了<"+num2+">步");
        //关闭线程池
        executor.shutdown();
    }
3、线程安全
  • 并发：多个线程访问同一份资源
  • 同步(synchronized)：保证资源具有原子性
    注：过多的同步会造成线程死锁
  • 单例模式之同步：
package designpattern.singleton;

/**
 * @author XuelinR
 *  单例模式
 *  创建步骤：a、私有的静态属性；b、构造器私有化；c、对外提供公共的静态的访问方法。
 *  1、懒汉式
 */
public class Singleton {
    //私有的静态属性
	private static Singleton singleton = null;
	//构造器私有化
	private Singleton() {
	}
	//提供对外的公共访问方法，这里要确保在多线程访问时的安全性
	//double check
	public static Singleton getInstence() {
	    if(null == singleton) {
	        synchronized(Singleton.class){
	            if(null == singleton) {
	                singleton = new Singleton();
	            }
	        }
	    }
		return singleton;
	}
}
/**
 * 
 * <p>Title:Singleton2</p>
 * <p>Description:单例模式之饿汉式</p>
 * @author XuelinR
 * @date 2019年5月30日
 * 2、饿汉式
 */
class Singleton2 {
    //私有的静态属性，这里一开始就创建对象
    private static Singleton2 singleton = new Singleton2();
    //构造器私有化
    private Singleton2() {}
    //对外提供公共的访问方法
    public static Singleton2 getInstence() {
        return singleton;
    }
}
/**
 * <p>Title:Singleton3</p>
 * <p>Description:单例模式之饿汉式内部类</p>
 * @author XuelinR
 * @date 2019年5月30日
 *
 */
class Singleton3 {
    //创建私有的静态的内部类，延迟加载，确保在使用对象时加载，提高性能
    private static class SingletonHoder{
        private static Singleton3 singleton = new Singleton3();
    }
    //构造器私有化
    private Singleton3() {}
    //对外提供公共的静态的访问方法
    public static Singleton3 getInstence() {
        return SingletonHoder.singleton;
    }
}
  • 生产者消费者模式，解决多线程访问死锁的问题
/**
 * <p>Title:Movie.java</p>
 * <p>Description:</p>
 * @author XuelinR
 * @date 2019年5月30日
 * @version 
 */
package threads;

/**
 * <p>Title:Movie</p>
 * <p>Description:生产者、消费者</p>
 * @author XuelinR
 * @date 2019年5月30日
 *
 */
public class Product {
    private String pic;
    //
    private boolean flag = true;
    /**
     * <p>Title:produce</p>
     * <p>Description:生产</p>
     * @param pic
     */
    public synchronized void produce(String pic){
        //Producer
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //begin product
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.pic = pic;
        System.out.println("produce:"+pic);
        //over produce
        this.notify();
        //stop produce
        this.flag = false;
    }
    /**
     * <p>Title:consume</p>
     * <p>Description:消费</p>
     */
    public synchronized void consume() {
        //Consumer
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("consume:"+pic);
        //over consume
        this.notify();
        //stop consume
        this.flag = true;
    }
    //测试生产者消费者
    public static void main(String[] args) {
        Product pt = new Product();
        Producer pd = new Producer(pt);
        Consumer cs = new Consumer(pt);
        new Thread(pd).start();
        new Thread(cs).start();
    }
}

生产者：

/**
 * <p>Title:Producer.java</p>
 * <p>Description:</p>
 * @author XuelinR
 * @date 2019年5月30日
 * @version 
 */
package threads;

/**
 * <p>Title:Producer</p>
 * <p>Description:</p>
 * @author XuelinR
 * @date 2019年5月30日
 *
 */
public class Producer implements Runnable {
    private Product pt;
    
    /**
     * @param m
     */
    public Producer(Product pt) {
        super();
        this.pt = pt;
    }

    /* (non-Javadoc)
     * <p>Title:run</p>
     * <p>Description:</p>
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            if (i%2==0) {
                pt.produce("三国演义");
            } else {
                pt.produce("西游记");
            }
        }
    }

}

消费者：

/**
 * <p>Title:player.java</p>
 * <p>Description:</p>
 * @author XuelinR
 * @date 2019年5月30日
 * @version 
 */
package threads;

/**
 * <p>Title:player</p>
 * <p>Description:生产者</p>
 * @author XuelinR
 * @date 2019年5月30日
 *
 */
public class Consumer implements Runnable {
    private Product pt;
    
    /**
     * @param m
     */
    public Consumer(Product pt) {
        super();
        this.pt = pt;
    }

    /* (non-Javadoc)
     * <p>Title:run</p>
     * <p>Description:</p>
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            pt.consume();
        }
    }

}
那夜那风
关注
专栏目录
多线程与并发服务器设计
wk_bjut_edu_cn的博客
06-28 2791
常见并发服务器方案 1.iterative(循环式/迭代式)服务器     iterative 只能使用短连接（每处理完一个连接，然后就关闭连接，称为短连接），不能使用长连接，如果使用长连接，意味着write需要转到read，那么整个程序就是一个单线程程序，如果此时有其它线程过来，没有办法接受连接，因为前一个线程还在read-&gt;write的循环中。也就是说如果使用长连接的话，这个程序...
Java多线程与并发库高级应用
08-16
并发库高级应用\多线程\Java
线程的创建及性能
m0_48273471的博客
03-21 503
1. 线程的使用
Java多线程与并发
lydms的博客
06-21 1万+
假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B、C想要调用这个对象的某个 synchronized方法（或者块），由于B、C线程在进入对象的 synchronized方法（或者块）之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wat（）方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
C语言系列12——多线程与并发编程
theskylife的博客
02-19 3114
在计算机编程领域，多线程与并发编程是一项重要的技术，它允许程序同时执行多个任务，提高了系统资源的利用率和程序执行效率。本文将介绍多线程的基本概念、应用场景，以及如何使用POSIX线程库进行编程，同时探讨线程同步与互斥锁的原理与应用，以避免竞态条件的发生。
Java多线程与并发编程
pythontxt的博客
05-10 1042
Java多线程与并发编程
Java多线程并发编程技术详解
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 3万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
go语言多线程与并发编程
luoye4321的专栏
09-06 2万+
go语言并发编程 在了解go语言的并发编程之前，我们必须先了解并发和并行的概念。我们知道，当启动一个应用的时候实际上是启动了一个进程，通过该进程实现资源的调度和分配，并且多个进程之间是相互隔离的，所以我们运行其中一个应用不会对其他应用造成影响。 默认情况下一个进程只有一个线程，也就是单线程应用，这种模式下所有的操作都是同步的，处理完A事件以后才能接着处理B事件再接着处理C事件。 那么，单线程...
多线程和并发的区别
勿念先生的博客
03-25 5139
    并发与多线程之间的关系就是目的与手段之间的关系。    并发（Concurrent）的反面是串行，串行好比多个车辆行驶在一股车道上，它们只能“鱼贯而行”。而并发好比多个车辆行驶在多股车道上，它们可以“并驾齐驱”。并发的极致就是并行（Parallel）。多线程就是将原本可能是串行的计算“改为”并发（并行）的一种手段、途径或者模型。    因此，有时我们也称多线程编程为并发编程。当然，目的与手...
【Java基础教程】（四十二）多线程篇 · 上：多进程与多线程、并发与并行的关系，多线程的实现方式、线程流转状态、常用操作方法解析~
Technology changes the world of life
07-22 2万+
本文主要介绍了多线程编程中的关键概念以及常用的操作方法。首先，我们了解了线程与进程之间的关系，明白了多进程、多线程、并发和并行之间的区别。接着，我们探讨了多线程的实现方式，包括继承Thread类、实现Runnable接口和利用Callable接口实现多线程，并对它们进行了比较和分析。然后，我们详细讲解了线程的操作状态，帮助读者理解线程在不同状态间的转换情况。最后，我们介绍了多线程常用的操作方法，如线程的命名与获取、线程的休眠、线程优先级、线程等待和线程让出执行权等。
多线程并发
qq_40126996的博客
01-18 2667
总结： 多线程并发 (一) 了解 Java 虚拟机 - JVM 学习知道了创建一个线程会触发JVM创建一个私有的虚拟机栈、程序计数器，当前的虚拟机栈内存就是当前线程的运行内存，程序计数器就是记录当前线程运行的代码的地址。 多线程并发 (二) 了解 Thread 学习了线程的运行状态、线程的创建方式、调度原理等。 多线程并发 (三) 锁 synchronized、volatile...
Java_多线程与并发编程总结.doc
04-14
Java多线程与并发编程是Java开发中至关重要的一部分，它涉及到如何高效地利用CPU资源，以实现程序的并行执行。在操作系统层面，多任务和多进程是通过分配不同的内存空间来实现的，而线程则共享同一进程的内存，这...
Java多线程与并发系列22道高频面试题（附思维导图和答案解析）
06-21
Java多线程与并发系列知识点 Java多线程与并发系列知识点是Java开发人员面试中经常被问到的一个重要话题。理解多线程与并发编程的知识，可以帮助开发人员更好地编写高效、可靠的Java程序。本文总结了Java多线程与...
Java多线程与并发库视频资源网盘链接
04-11
Java多线程与并发库是Java开发者必备的重要技能之一，尤其对于处理高并发场景的应用开发至关重要。本视频资源集合旨在帮助初级开发人员深入理解和掌握这一关键领域，通过学习，你可以提升自己的程序性能优化能力，更...
【多线程】多线程（8）：单例模式：阻塞队列
2301_81305165的博客
10-05 1072
A的角色是一个“网关服务器”，收到客户端的请求，再把请求转发给其他的服务器，这样的服务器里面的代码做的工作比较简单（单纯的数据转发），消耗的硬件资源通常更少，处理一个请求消耗的资源更少，同样的配置下就能支持更多的请求处理。B这个服务器是真正干活的服务器，要真正完成一系列的业务逻辑，代码量十分庞大，消耗的时间和系统硬件资源更多，同一时刻可以支撑的请求数量更少。服务器每次收到一个请求，处理这个请求的过程就需要执行一系列的代码，在执行这些代码的过程中，就会需要消耗一定的硬件资源。
设计模式：单例模式
最新发布
HR_Reborn的博客
10-09 76
单例模式保证一个类只有一个实例，并且提供了全局访问该实例的方法。而懒汉则是有一种能少创建就少创建的偷懒的感觉，即只要在第一次调用获取实例的方法时才会创建唯一实例，从而节省资源。总结：饿汉单例适合在程序启动时资源充足，且需要立即使用单例的场景。懒汉单例适合资源敏感的场景，或者单例实例较大且不一定每次都需要实例化时使用。饿汉就是一点不顾一切的感觉，在类加载的时候就创建唯一的单例实例，不论该实例是否会被使用。在写具体代码之前还需要知道单例模式的两种分类，饿汉和懒汉。所谓的饿和懒其实是创建实例的状态形容。
C#中的static关键字：静态成员与单例模式的实现
学习和分享
10-02 489
在C#中，static关键字是一个非常重要的概念，它用于声明静态成员，这些成员属于类本身，而不是类的任何特定实例。使用static关键字可以定义静态类、静态字段、静态属性、静态方法等。此外，理解静态成员也对于实现如单例模式这样的设计模式至关重要。
线程安全的单例模式 | 可重入 | 线程安全 |死锁（理论）
Giggins GaoBlog
10-05 1181
线程安全的单例模式 | 可重入 | 线程安全 |死锁（理论）
Java多线程与并发编程详解
"Java多线程与并发编程的深度总结" 在计算机科学中，多线程和并发编程是提升系统性能和效率的关键技术。Java语言提供了丰富的支持来处理多线程场景，使得开发者能够充分利用现代多核处理器的计算能力。 首先，多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值