高并发下线程安全的单例模式（最全最经典）

最新推荐文章于 2024-07-03 18:07:54 发布
置顶 最新推荐文章于 2024-07-03 18:07:54 发布
阅读量10w+ 收藏 509
点赞数 145
分类专栏： 设计模式 文章标签： 线程安全 单例模式 线程安全的单例 并发编程 JAVA设计模式之单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cselmu9/article/details/51366946
版权

在所有的设计模式中，单例模式是我们在项目开发中最为常见的设计模式之一，而单例模式有很多种实现方式，你是否都了解呢？高并发下如何保证单例模式的线程安全性呢？如何保证序列化后的单例对象在反序列化后任然是单例的呢？这些问题在看了本文之后都会一一的告诉你答案，赶快来阅读吧！

什么是单例模式?

在文章开始之前我们还是有必要介绍一下什么是单例模式。单例模式是为确保一个类只有一个实例，并为整个系统提供一个全局访问点的一种模式方法。

从概念中体现出了单例的一些特点：

（1）、在任何情况下，单例类永远只有一个实例存在

（2）、单例需要有能力为整个系统提供这一唯一实例 


为了便于读者更好的理解这些概念，下面给出这么一段内容叙述：

在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。

正是由于这个特点，单例对象通常作为程序中的存放配置信息的载体，因为它能保证其他对象读到一致的信息。例如在某个服务器程序中，该服务器的配置信息可能存放在数据库或文件中，这些配置数据由某个单例对象统一读取，服务进程中的其他对象如果要获取这些配置信息，只需访问该单例对象即可。这种方式极大地简化了在复杂环境 下，尤其是多线程环境下的配置管理，但是随着应用场景的不同，也可能带来一些同步问题。
    

各式各样的单例实现

温馨提示：本文叙述中涉及到的相关源码可以在这里进行下载源码，读者可免积分下载。

1、饿汉式单例

饿汉式单例是指在方法调用前，实例就已经创建好了。下面是实现代码：

package org.mlinge.s01;

public class MySingleton {
	
	private static MySingleton instance = new MySingleton();
	
	private MySingleton(){}
	
	public static MySingleton getInstance() {
		return instance;
	}
	
}
以上是单例的饿汉式实现，我们来看看饿汉式在多线程下的执行情况，给出一段多线程的执行代码： 

package org.mlinge.s01;

public class MyThread extends Thread{
  	
	@Override
	public void run() { 
		System.out.println(MySingleton.getInstance().hashCode());
	}
	
	public static void main(String[] args) { 
		
		MyThread[] mts = new MyThread[10];
		for(int i = 0 ; i < mts.length ; i++){
			mts[i] = new MyThread();
		}
		
		for (int j = 0; j < mts.length; j++) {
			mts[j].start();
		}
	}
}

以上代码运行结果：

1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954

从运行结果可以看出实例变量额hashCode值一致，这说明对象是同一个，饿汉式单例实现了。

2、懒汉式单例

懒汉式单例是指在方法调用获取实例时才创建实例，因为相对饿汉式显得“不急迫”，所以被叫做“懒汉模式”。下面是实现代码：

package org.mlinge.s02;

public class MySingleton {
	
	private static MySingleton instance = null;
	
	private MySingleton(){}
	
	public static MySingleton getInstance() {
		if(instance == null){//懒汉式
			instance = new MySingleton();
		}
		return instance;
	}
}
这里实现了懒汉式的单例，但是熟悉多线程并发编程的朋友应该可以看出，在多线程并发下这样的实现是无法保证实例实例唯一的，甚至可以说这样的失效是完全错误的，下面我们就来看一下多线程并发下的执行情况，这里为了看到效果，我们对上面的代码做一小点修改： 

package org.mlinge.s02;

public class MySingleton {
	
	private static MySingleton instance = null;
	
	private MySingleton(){}
	
	public static MySingleton getInstance() {
		try { 
			if(instance != null){//懒汉式 
				
			}else{
				//创建实例之前可能会有一些准备性的耗时工作 
				Thread.sleep(300);
				instance = new MySingleton();
			}
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}
		return instance;
	}
}
这里假设在创建实例前有一些准备性的耗时工作要处理，多线程调用： 

package org.mlinge.s02;

public class MyThread extends Thread{
  	
	@Override
	public void run() { 
		System.out.println(MySingleton.getInstance().hashCode());
	}
	
	public static void main(String[] args) { 
		
		MyThread[] mts = new MyThread[10];
		for(int i = 0 ; i < mts.length ; i++){
			mts[i] = new MyThread();
		}
		
		for (int j = 0; j < mts.length; j++) {
			mts[j].start();
		}
	}
}

执行结果如下：

1210420568
1210420568
1935123450
1718900954
1481297610
1863264879
369539795
1210420568
1210420568
602269801

从这里执行结果可以看出，单例的线程安全性并没有得到保证，那要怎么解决呢？

3、线程安全的懒汉式单例

要保证线程安全，我们就得需要使用同步锁机制，下面就来看看我们如何一步步的解决 存在线程安全问题的懒汉式单例（错误的单例）。

（1）、 方法中声明synchronized关键字

出现非线程安全问题，是由于多个线程可以同时进入getInstance()方法，那么只需要对该方法进行synchronized的锁同步即可：

package org.mlinge.s03;

public class MySingleton {
	
	private static MySingleton instance = null;
	
	private MySingleton(){}
	
	public synchronized static MySingleton getInstance() {
		try { 
			if(instance != null){//懒汉式 
				
			}else{
				//创建实例之前可能会有一些准备性的耗时工作 
				Thread.sleep(300);
				instance = new MySingleton();
			}
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}
		return instance;
	}
}

此时任然使用前面验证多线程下执行情况的MyThread类来进行验证，将其放入到org.mlinge.s03包下运行，执行结果如下：

1689058373
1689058373
1689058373
1689058373
1689058373
1689058373
1689058373
1689058373
1689058373
1689058373

从执行结果上来看，问题已经解决了，但是这种实现方式的运行效率会很低。同步方法效率低，那我们考虑使用同步代码块来实现：

（2）、 同步代码块实现

package org.mlinge.s03;

public class MySingleton {
	
	private static MySingleton instance = null;
	
	private MySingleton(){}
	
	//public synchronized static MySingleton getInstance() {
	public static MySingleton getInstance() {
		try { 
			synchronized (MySingleton.class) {
				if(instance != null){//懒汉式 
					
				}else{
					//创建实例之前可能会有一些准备性的耗时工作 
					Thread.sleep(300);
					instance = new MySingleton();
				}
			}
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}
		return instance;
	}
}
这里的实现能够保证多线程并发下的线程安全性，但是这样的实现将全部的代码都被锁上了，同样的效率很低下。

（3）、 针对某些重要的代码来进行单独的同步（可能非线程安全）

针对某些重要的代码进行单独的同步，而不是全部进行同步，可以极大的提高执行效率，我们来看一下：

package org.mlinge.s04;

public class MySingleton {
	
	private static MySingleton instance = null;
	
	private MySingleton(){}
	 
	public static MySingleton getInstance() {
		try {  
			if(instance != null){//懒汉式 
				
			}else{
				//创建实例之前可能会有一些准备性的耗时工作 
				Thread.sleep(300);
				synchronized (MySingleton.class) {
					instance = new MySingleton();
				}
			} 
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}
		return instance;
	}
}
此时同样使用前面验证多线程下执行情况的MyThread类来进行验证，将其放入到org.mlinge.s04包下运行，执行结果如下： 
1481297610
397630378
1863264879
1210420568
1935123450
369539795
590202901
1718900954
1689058373
602269801
从运行结果来看，这样的方法进行代码块同步，代码的运行效率是能够得到提升，但是却 没能保住线程的安全性。看来还得进一步考虑如何解决此问题。

（4）、 Double Check Locking 双检查锁机制（推荐）

为了达到线程安全，又能提高代码执行效率，我们这里可以采用DCL的双检查锁机制来完成，代码实现如下：

package org.mlinge.s05;

public class MySingleton {
	
	//使用volatile关键字保其可见性
	volatile private static MySingleton instance = null;
	
	private MySingleton(){}
	 
	public static MySingleton getInstance() {
		try {  
			if(instance != null){//懒汉式 
				
			}else{
				//创建实例之前可能会有一些准备性的耗时工作 
				Thread.sleep(300);
				synchronized (MySingleton.class) {
					if(instance == null){//二次检查
						instance = new MySingleton();
					}
				}
			} 
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}
		return instance;
	}
}
将前面验证多线程下执行情况的MyThread类放入到org.mlinge.s05包下运行，执行结果如下： 
369539795
369539795
369539795
369539795
369539795
369539795
369539795
369539795
369539795
369539795
从运行结果来看，该中方法保证了多线程并发下的线程安全性。

这里在声明变量时使用了volatile关键字来保证其线程间的可见性；在同步代码块中使用二次检查，以保证其不被重复实例化。集合其二者，这种实现方式既保证了其高效性，也保证了其线程安全性。

4、使用静态内置类实现单例模式

DCL解决了多线程并发下的线程安全问题，其实使用其他方式也可以达到同样的效果，代码实现如下：

package org.mlinge.s06;

public class MySingleton {
	
	//内部类
	private static class MySingletonHandler{
		private static MySingleton instance = new MySingleton();
	} 
	
	private MySingleton(){}
	 
	public static MySingleton getInstance() { 
		return MySingletonHandler.instance;
	}
}
以上代码就是使用静态内置类实现了单例模式，这里将前面验证多线程下执行情况的MyThread类放入到org.mlinge.s06包下运行，执行结果如下： 
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
从运行结果来看，静态内部类实现的单例在多线程并发下单个实例得到了保证。

5、序列化与反序列化的单例模式实现

静态内部类虽然保证了单例在多线程并发下的线程安全性，但是在遇到序列化对象时，默认的方式运行得到的结果就是多例的。

代码实现如下：

package org.mlinge.s07;

import java.io.Serializable;

public class MySingleton implements Serializable {
	 
	private static final long serialVersionUID = 1L;

	//内部类
	private static class MySingletonHandler{
		private static MySingleton instance = new MySingleton();
	} 
	
	private MySingleton(){}
	 
	public static MySingleton getInstance() { 
		return MySingletonHandler.instance;
	}
}
序列化与反序列化测试代码： 

package org.mlinge.s07;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SaveAndReadForSingleton {
	
	public static void main(String[] args) {
		MySingleton singleton = MySingleton.getInstance();
		
		File file = new File("MySingleton.txt");
		
		try {
			FileOutputStream fos = new FileOutputStream(file);
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			oos.writeObject(singleton);
			fos.close();
			oos.close();
			System.out.println(singleton.hashCode());
		} catch (FileNotFoundException e) { 
			e.printStackTrace();
		} catch (IOException e) { 
			e.printStackTrace();
		}
		
		try {
			FileInputStream fis = new FileInputStream(file);
			ObjectInputStream ois = new ObjectInputStream(fis);
			MySingleton rSingleton = (MySingleton) ois.readObject();
			fis.close();
			ois.close();
			System.out.println(rSingleton.hashCode());
		} catch (FileNotFoundException e) { 
			e.printStackTrace();
		} catch (IOException e) { 
			e.printStackTrace();
		} catch (ClassNotFoundException e) { 
			e.printStackTrace();
		}
		
	}
}
运行以上代码，得到的结果如下： 

865113938
1442407170
从结果中我们发现，序列号对象的hashCode和反序列化后得到的对象的hashCode值不一样，说明反序列化后返回的对象是重新实例化的，单例被破坏了。那怎么来解决这一问题呢？

解决办法就是在反序列化的过程中使用readResolve()方法，单例实现的代码如下：

package org.mlinge.s07;

import java.io.ObjectStreamException;
import java.io.Serializable;

public class MySingleton implements Serializable {
	 
	private static final long serialVersionUID = 1L;

	//内部类
	private static class MySingletonHandler{
		private static MySingleton instance = new MySingleton();
	} 
	
	private MySingleton(){}
	 
	public static MySingleton getInstance() { 
		return MySingletonHandler.instance;
	}
	
	//该方法在反序列化时会被调用，该方法不是接口定义的方法，有点儿约定俗成的感觉
	protected Object readResolve() throws ObjectStreamException {
		System.out.println("调用了readResolve方法！");
		return MySingletonHandler.instance; 
	}
}
再次运行上面的测试代码，得到的结果如下： 

865113938
调用了readResolve方法！
865113938
从运行结果可知，添加readResolve方法后反序列化后得到的实例和序列化前的是同一个实例，单个实例得到了保证。

6、使用static代码块实现单例

静态代码块中的代码在使用类的时候就已经执行了，所以可以应用静态代码块的这个特性的实现单例设计模式。

package org.mlinge.s08;

public class MySingleton{
	 
	private static MySingleton instance = null;
	 
	private MySingleton(){}

	static{
		instance = new MySingleton();
	}
	
	public static MySingleton getInstance() { 
		return instance;
	} 
}
测试代码如下： 

package org.mlinge.s08;

public class MyThread extends Thread{
  	
	@Override
	public void run() { 
		for (int i = 0; i < 5; i++) {
			System.out.println(MySingleton.getInstance().hashCode());
		}
	}
	
	public static void main(String[] args) { 
		
		MyThread[] mts = new MyThread[3];
		for(int i = 0 ; i < mts.length ; i++){
			mts[i] = new MyThread();
		}
		
		for (int j = 0; j < mts.length; j++) {
			mts[j].start();
		}
	}
}
运行结果如下： 

1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
1718900954
从运行结果看，单例的线程安全性得到了保证。

7、使用枚举数据类型实现单例模式

枚举enum和静态代码块的特性相似，在使用枚举时，构造方法会被自动调用，利用这一特性也可以实现单例：

package org.mlinge.s09;

public enum EnumFactory{ 
    
    singletonFactory;
    
    private MySingleton instance;
    
    private EnumFactory(){//枚举类的构造方法在类加载是被实例化
        instance = new MySingleton();
    }
        
    public MySingleton getInstance(){
        return instance;
    }
    
}

class MySingleton{//需要获实现单例的类，比如数据库连接Connection
    public MySingleton(){} 
}
测试代码如下： 

package org.mlinge.s09;

public class MyThread extends Thread{
  	
	@Override
	public void run() { 
		System.out.println(EnumFactory.singletonFactory.getInstance().hashCode());
	}
	
	public static void main(String[] args) { 
		
		MyThread[] mts = new MyThread[10];
		for(int i = 0 ; i < mts.length ; i++){
			mts[i] = new MyThread();
		}
		
		for (int j = 0; j < mts.length; j++) {
			mts[j].start();
		}
	}
}
执行后得到的结果： 
1481297610
1481297610
1481297610
1481297610
1481297610
1481297610
1481297610
1481297610
1481297610
1481297610
运行结果表明单例得到了保证，但是这样写枚举类被完全暴露了，据说违反了“职责单一原则”，那我们来看看怎么进行改造呢。

8、完善使用enum枚举实现单例模式

不暴露枚举类实现细节的封装代码如下：

package org.mlinge.s10;

public class ClassFactory{ 
	
	private enum MyEnumSingleton{
		singletonFactory;
		
		private MySingleton instance;
		
		private MyEnumSingleton(){//枚举类的构造方法在类加载是被实例化
			instance = new MySingleton();
		}
 
		public MySingleton getInstance(){
			return instance;
		}
	} 
 
	public static MySingleton getInstance(){
		return MyEnumSingleton.singletonFactory.getInstance();
	}
}

class MySingleton{//需要获实现单例的类，比如数据库连接Connection
	public MySingleton(){} 
}
验证单例实现的代码如下： 

package org.mlinge.s10;

public class MyThread extends Thread{
  	
	@Override
	public void run() { 
		System.out.println(ClassFactory.getInstance().hashCode());
	}
	
	public static void main(String[] args) { 
		
		MyThread[] mts = new MyThread[10];
		for(int i = 0 ; i < mts.length ; i++){
			mts[i] = new MyThread();
		}
		
		for (int j = 0; j < mts.length; j++) {
			mts[j].start();
		}
	}
}
验证结果： 

1935123450
1935123450
1935123450
1935123450
1935123450
1935123450
1935123450
1935123450
1935123450
1935123450
验证结果表明，完善后的单例实现更为合理。

以上就是本文要介绍的所有单例模式的实现，相信认真阅读的读者都已经明白文章开头所引入的那几个问题了，祝大家读得开心:-D！


备注：本文的编写思路和实例源码参照《Java多线程编程核心技术》-（高洪岩）一书中第六章的学习案例撰写。


mlinge-奋斗吧
关注
  • 145
    点赞
  • 踩
  • 509
    收藏
    觉得还不错? 一键收藏
  • 65
    评论
专栏目录
线程安全的单例模式
weixin_44405652的博客
05-15 338
线程安全的单例模式： 单例模式：属于创建类型的一种常用的软件设计模式，通过单例模式创建的类在当前进程中只有一个实例，一份资源只能被申请加载一次。 如何实现： 饿汉模式：资源在程序初始化的时候就去加载，后边使用的时候直接使用，使用会非常流畅，但是有可能会加载上根本用不到的资源，而且程序初始化的时间也会较慢 懒汉模式：在进行资源的使用时，缺少这个资源才去加载，程序初始化的速度比较快，但是初次加载某个模块时会比较慢，因为这时候需要加载相应的资源。 饿汉模式实现方式： 使用static将某成员变量定义为
.net core并发下线程安全问题详解
10-17
在.NET Core并发环境中，线程安全问题至关重要，尤其是在高并发的应用场景中。这些问题是由于多线程访问共享资源时可能出现的竞态条件、死锁、数据不一致等问题导致的。以下是一些关于.NET Core并发线程安全的关键...
用单例模式来讲解c++11新特性
最新发布
weixin_61503529的博客
07-03 627
c++11新特性
最安全的单例模式-枚举
瑞文のBlog
01-17 940
枚举实现 首先我们先看一下枚举实现单例模式 public enum EnumSingleton { INSTANCE; // 枚举能够绝对有效的防止实例化多次,和防止反射和序列化破解 public void add() { System.out.println("add方法..."); } } Test类 public class Test { public static void main(String[] args) { E
安全的单例模式
weixin_42204082的博客
05-01 901
单例模式的形式与安全性 单例模式的应用场景 绝大多数玩过Java的同学应该都有了解过单例模式，而为什么我们需要使用单例模式？它的应用场景是什么呢？ 想到单例模式可能会想到数据库连接池，或者在Spring框架中的ApplicationContext上下文等等，而它们为什么要做成单例？如果不是单例有什么问题呢？ 我们先明白单例模式的概念：确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。这里说的任何情况一般指的是虚拟机管理的内存中唯一。 为什么连接池要是单例的呢？我们要知道计算机的资源是有限的，而
安全单例模式
Ck_8023的博客
12-18 435
一、类部的静态成员内部类，缺省同步延迟加载，只执行单独工作域对性能并没有损耗。 1.1此方法为安全的单例设计模式
单例模式的枚举实现-＞最安全的单例
qq_43433860的博客
01-18 264
枚举实现单例是最安全的单例实现方式 实现代码 准备枚举类 /** * 注册式单例第一种：枚举式单例 */ public enum EunmSingleton { INSTANCE; private Object data; public static EunmSingleton getInstance(){return INSTANCE;} public Object getData() { return data; } publ
【ASP.NET编程知识】.net core并发下线程安全问题详解.docx
05-15
在.NET Core并发环境下，线程安全问题是一个关键的议题，特别是在ASP.NET Core的WebAPI项目中，由于高并发请求的特性，可能导致多个线程同时访问共享资源，从而引发各种异常。文档中提到的问题主要集中在数据库上...
linux 下线程安全的singleton
04-18
singleton是最常见的设计模式,但是要设计好却是不容易,尤其是多线程的时候,需要考虑线程安全的问题.
整机下线及调试安全操作规程.docx
10-02
【整机下线及调试安全操作规程】 在整机下线和调试过程中，安全操作是至关重要的，因为这涉及到人员的生命安全以及设备的完好。以下是根据文档内容整理的关键安全操作规程： 1. **底盘下线排故安全操作规程**： -...
Java 高并发三：Java内存模型和线程安全详解
09-01
本文主要介绍Java高并发内存模型和线程安全的资料，这里整理详细的资料及1.原子性 2.有序性 3.可见性 4.Happen-Before 5.线程安全的概念，有需要的小伙伴可以参考下
<转>单例模式 线程安全
i54fx的专栏
04-28 136
线程安全性的定义： 如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。 　　或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。 线程安全问题都是由全局变量及静态变...
线程安全之单例模式
m0_61869253的博客
03-16 1150
这篇文章,我们会介绍一下单例模式,但这里的单例模式,不是我们所说的设计模式,当然听到设计模式,大家一定都说,我当然知道设计模式了,有23种呢?一下子一顿输出,当然我这里说的单例模式还是跟设计模式有一些区别的,当然我不做概述,因为我也没咋个去了解过设计模式,我把大家拉回来,什么是多线程对的单例模式呢?看完我以下的解释相信你会明白的.多线程环境下的单例模式需要保证只有一个实例对象被创建，并且可以在多线程环境下安全地访问该实例。
关于线程安全的单例模式
ww464214415的博客
05-11 256
这是我写的第一篇博客请大家多多支持，如果有写的不对的地方，欢迎大家指正批评！今天和同事做公交车的时候，同事突然问了一下我单例模式，我说这有什么不会写的，但是同事又问了线程安全的单例模式，我也会写但是一问我问什么是安全的，我突然有点蒙，不知道怎么答，故而查了一下资料记录一下 1 //双重检查锁 2 public final class DoubleCheckedSingleton 3 { ...
一个线程安全的单例模式
小野爸爸的博客
06-17 181
/** * @author lhj * @Description: 一个线程安全的单例模式 * @date 2019/6/17 19:32 */ public class SingletonSafe { //私有化构造方法 private SingletonSafe(){ } //私有化一个静态的单例对象 //volatile的目的是防止JVM指...
线程安全单例模式
weixin_49258031的博客
08-03 157
本文主要介绍java的单例模式，以及详细剖析静态内部类之所以能够实现单例的原理。OK，废话不多说，进入正文。 首先我们要先了解下单例的四大原则： 1.构造私有。 2.以静态方法或者枚举返回实例。 3.确保实例只有一个，尤其是多线程环境。 4.确保反序列换时不会重新构建对象。 我们常用的单例模式有： 饿汉模式、懒汉模式、双重锁懒汉模式、静态内部类模式、枚举模式，我们来逐一分析下这些模式的区别。 1.饿汉模式： public class SingleTon{ private static SingleTon I
linux下线程实现串口通信例程
07-08
### 回答1： 在Linux系统下，可以使用线程实现串口通信例程。 首先，需要引入一些头文件，如`<stdio.h>, <stdlib.h>, <unistd.h>, <fcntl.h>, <termios.h>, <pthread.h>`，以便使用相关函数和数据结构。 接下来，打开串口设备文件，使用`open()`函数，并通过`<fcntl.h>`中的`O_RDWR`参数设置为可读写模式。例如，打开`/dev/ttyS0`串口设备： ```c int fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY); if (fd == -1) { perror("打开串口失败"); exit(EXIT_FAILURE); } ``` 然后，配置串口属性，包括波特率、数据位、停止位等。首先需要获取当前串口属性，使用`tcgetattr()`函数，并通过`<termios.h>`中的数据结构`struct termios`进行配置。例如，设置波特率为115200： ```c struct termios attr; if (tcgetattr(fd, &attr) == -1) { perror("获取串口属性失败"); close(fd); exit(EXIT_FAILURE); } cfsetispeed(&attr, B115200); cfsetospeed(&attr, B115200); if (tcsetattr(fd, TCSANOW, &attr) == -1) { perror("设置串口属性失败"); close(fd); exit(EXIT_FAILURE); } ``` 接下来，创建一个线程，用于接收串口数据。使用`pthread_create()`函数，并编写线程函数。例如，以下为接收串口数据的线程函数： ```c void *receiveThread(void *arg) { char buffer[256]; int len; while (1) { len = read(fd, buffer, sizeof(buffer)); if (len > 0) { // 处理接收到的数据 // ... } } return NULL; } pthread_t tid; pthread_create(&tid, NULL, receiveThread, NULL); ``` 最后，主线程（或其他线程）可以通过`write()`函数向串口发送数据。例如，向串口发送一个字符串： ```c char *str = "Hello, Serial!"; write(fd, str, strlen(str)); ``` 整个程序运行时，主线程可以继续执行其他任务，而串口数据的接收则在单独的线程中进行。 这样，就完成了一个简单的Linux下线程实现串口通信的例程。 ### 回答2： 在Linux下，可以通过使用线程来实现串口通信。下面是一个简单的示例代码： ```c #include <stdio.h> #include <fcntl.h> #include <termios.h> #include <unistd.h> #include <pthread.h> int fd; // 串口文件描述符 pthread_t thread_id; // 线程ID void* read_thread(void* arg) { char buf[255]; while(1) { int len = read(fd, buf, sizeof(buf)); // 从串口读取数据 if (len > 0) { buf[len] = '\0'; // 添加字符串结束符 printf("接收到的数据: %s\n", buf); } } } int main() { // 打开串口 fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY); if (fd == -1) { printf("无法打开串口\n"); return -1; } // 配置串口 struct termios options; tcgetattr(fd, &options); cfsetispeed(&options, B9600); cfsetospeed(&options, B9600); options.c_cflag |= (CLOCAL | CREAD); options.c_cflag &= ~PARENB; options.c_cflag &= ~CSTOPB; options.c_cflag &= ~CSIZE; options.c_cflag |= CS8; options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); tcsetattr(fd, TCSANOW, &options); // 创建读取数据的线程 pthread_create(&thread_id, NULL, read_thread, NULL); // 主线程继续执行其他任务 while(1) { // 发送数据到串口 char msg[] = "Hello, Serial Port!"; write(fd, msg, sizeof(msg)); usleep(1000000); // 等待1秒 } // 关闭串口 close(fd); return 0; } ``` 在上述代码中，通过`open`函数打开了串口设备文件`/dev/ttyS0`（请根据实际情况更改），然后使用`termios`结构体配置了串口的波特率、数据位、停止位等属性。接下来，通过`pthread_create`函数创建了一个线程，该线程负责读取串口数据。主线程则负责发送数据到串口。 需要注意的是，该例程只是一个简单的示例，仅用于说明线程实现串口通信的基本思路。实际应用中，还需考虑数据的解析、错误处理、线程同步等问题。 ### 回答3： 在Linux下，可以使用串口通信库来实现线程的串口通信例程。下面是一个简单的例子： 1. 首先，我们需要安装和配置串口通信库。常用的库包括`libserialport`和`termios`。你可以使用包管理工具来安装这些库。 2. 在程序中，我们需要引入相关的头文件和库： ``` #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <pthread.h> #include <serialport.h> ``` 3. 然后，创建一个线程来读取串口数据。可以定义一个函数作为线程入口点，例如`serial_read`： ``` void *serial_read(void *data) { struct sp_port *serial_port = (struct sp_port *)data; char buffer[256]; int n; while (1) { n = sp_blocking_read(serial_port, buffer, sizeof(buffer), 100); if (n > 0) { // 处理接收到的数据 printf("Received: %.*s\n", n, buffer); } else { // 读取数据出错或超时 printf("Serial read error or timeout\n"); } } return NULL; } ``` 4. 接下来，创建一个线程来发送串口数据。可以定义一个函数作为线程入口点，例如`serial_write`： ``` void *serial_write(void *data) { struct sp_port *serial_port = (struct sp_port *)data; char message[] = "Hello, Serial Port!\n"; while (1) { sp_nonblocking_write(serial_port, message, sizeof(message) - 1); usleep(1000000); // 暂停1秒钟 } return NULL; } ``` 5. 在主函数中，打开串口设备并创建两个线程： ``` int main() { struct sp_port *serial_port; pthread_t read_thread, write_thread; // 打开串口设备（例如：/dev/ttyS0） sp_get_port_by_name("ttyS0", &serial_port); sp_open(serial_port, SP_MODE_READ_WRITE); // 创建读取线程 pthread_create(&read_thread, NULL, serial_read, (void *)serial_port); // 创建写入线程 pthread_create(&write_thread, NULL, serial_write, (void *)serial_port); // 等待线程结束 pthread_join(read_thread, NULL); pthread_join(write_thread, NULL); // 关闭串口设备 sp_close(serial_port); sp_free_port(serial_port); return 0; } ``` 这是一个简单的例程，通过两个线程实现了线程的串口通信。读取线程通过不断调用`sp_blocking_read`函数读取串口数据，而写入线程通过不断调用`sp_nonblocking_write`函数发送串口数据。你可以根据需求来修改和扩展这个例程。
评论 65
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值