欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java编程多线程之共享数据代码详解

程序员文章站 2022-10-10 17:30:12
本文主要总结线程共享数据的相关知识,主要包括两方面:一是某个线程内如何共享数据,保证各个线程的数据不交叉;一是多个线程间如何共享数据,保证数据的一致性。 线程范围内共享数...

本文主要总结线程共享数据的相关知识,主要包括两方面:一是某个线程内如何共享数据,保证各个线程的数据不交叉;一是多个线程间如何共享数据,保证数据的一致性。

线程范围内共享数据

自己实现的话,是定义一个map,线程为键,数据为值,表中的每一项即是为每个线程准备的数据,这样在一个线程中数据是一致的。

例子

package com.iot.thread;
import java.util.hashmap;
import java.util.map;
import java.util.random;
/**
 * created by brian on 2016/2/4.
 */
public class threadscopesharedata {
	//准备一个哈希表,为每个线程准备数据
	private static map<thread,integer> threaddata = new hashmap<>();
	public static void main(string[] args) {
		for (int i=0;i<2;i++){
			new thread(
			          new runnable() {
				@override
				        public void run() {
					int data = new random().nextint();
					threaddata.put(thread.currentthread(),data);
					system.out.println(thread.currentthread()+" put data:"+data);
					new a().get();
					new b().get();
				}
			}
			).start();
		}
	}
	static class a{
		public void get(){
			int data = threaddata.get(thread.currentthread());
			system.out.println("a from "+thread.currentthread()+" get data "+data);
		}
	}
	static class b{
		public void get(){
			int data = threaddata.get(thread.currentthread());
			system.out.println("b from "+thread.currentthread()+" get data "+data);
		}
	}
}

上述代码偶尔会报异常:

exception in thread "thread-0" java.lang.nullpointerexception
at com.iot.thread.threadscopesharedata$a.get(threadscopesharedata.java:29)
at com.iot.thread.threadscopesharedata$1.run(threadscopesharedata.java:21)
at java.lang.thread.run(thread.java:745)

具体原因还不知道

threadlocal类

api:

java.lang:class threadlocal<t>

  • 单变量

使用threadlocal类型的对象代替上面的map即可

  • 多变量

定义一个对象来封装多个变量,然后在threadlocal中存储整个对象

多变量时,最好将threadlocal类放在数据类的内部,数据类采用单例模式,这样,新建对象和获取对象都会更方便,同时封装性更强。

示例代码:

package com.iot.thread;
import java.util.random;
/**
 * created by brian on 2016/2/4.
 */
public class threadlocaltest {
	private static threadlocal<integer> threadinger = new threadlocal<>();
	public static void main(string[] args) {
		for (int i=0;i<2;i++){
			new thread(new runnable() {
				@override
				        public void run() {
					int data = new random().nextint(100);
					threadinger.set(data);
					system.out.println(thread.currentthread()+" put data:"+data);
					mythreadscopedata.getthreadinstance().setname(thread.currentthread().tostring());
					mythreadscopedata.getthreadinstance().setage(data%10);
					new a().get();
					new b().get();
				}
			}
			).start();
		}
	}
	static class a{
		public void get(){
			int data = threadinger.get();
			system.out.println("a from "+thread.currentthread()+" get data "+data);
			mythreadscopedata mythreadscopedata = mythreadscopedata.getthreadinstance();
			system.out.println("a from "+mythreadscopedata);
		}
	}
	static class b{
		public void get(){
			int data = threadinger.get();
			system.out.println("b from "+thread.currentthread()+" get data "+data);
			mythreadscopedata mythreadscopedata = mythreadscopedata.getthreadinstance();
			system.out.println("b from "+mythreadscopedata);
		}
	}
}
/**
 * 将多变量封装起来的数据类
 * 单例模式,内置threadlocal类型变量
 */
class mythreadscopedata{
	private mythreadscopedata(){
	}
	private static threadlocal<mythreadscopedata> data = new threadlocal<>();
	public static mythreadscopedata getthreadinstance(){
		mythreadscopedata instance = data.get();
		if(instance == null){
			instance = new mythreadscopedata();
			data.set(instance);
		}
		return instance;
	}
	private string name;
	private int age;
	public string getname() {
		return name;
	}
	public void setname(string name) {
		this.name = name;
	}
	public int getage() {
		return age;
	}
	public void setage(int age) {
		this.age = age;
	}
	@override
	  public string tostring() {
		string reval = super.tostring()+"-{name,age}"+":{"+getname()+","+getage()+"}";
		return reval;
	}
}

多线程访问共享数据

几种方式

  • 线程执行代码相同,使用同一runnable对象,runnable对象中有共享数据
  • 线程执行代码不同,将共享数据封装在另一对象中(操作数据的方法也在该对象完成),将这个对象逐一传递给各个runnable对象。[本质:共享数据的对象作为参数传入runnable对象]
  • 线程执行代码不同,将runnable对象作为某一个类的内部类,共享数据作为这个外部类的成员变量(操作数据的方法放在外部类)。[本质:不同内部类共享外部类数据]
  • 结合上两种方式,将共享数据封装在另一对象中(操作数据的方法也在该对象完成),该对象作为这个外部类的成员变量,将runnable对象作为内部类

最后一种方式的示例:

设计5个线程,其中三个线程每次对j增加1,另外两个线程对j每次减少1

package com.iot.thread;
/**
 * created by brian on 2016/2/4.
 */
public class mutithreadsharedata {
	private static mutisharedata mutisharedata = new mutisharedata();
	public static void main(string[] args) {
		for (int i=0;i<3;i++){
			new thread(
			          new runnable() {
				@override
				            public void run() {
					system.out.println(thread.currentthread()+":{j from "+ mutisharedata.getj()+" + to: "+mutisharedata.increment()+"}");
				}
			}
			).start();
		}
		for (int i=0;i<2;i++){
			new thread(
			          new runnable() {
				@override
				            public void run() {
					system.out.println(thread.currentthread()+":{j from "+ mutisharedata.getj()+" - to: "+mutisharedata.decrement()+"}");
				}
			}
			).start();
		}
	}
}
/**
 * 将共享数据封装在另一对象中(操作数据的方法也在该对象完成)
 */
class mutisharedata{
	private int j = 0;
	public synchronized int increment(){
		return ++j;
	}
	public synchronized int decrement(){
		return --j;
	}
	public synchronized int getj() {
		return j;
	}
	public synchronized void setj(int j) {
		this.j = j;
	}
}

总结

以上就是本文关于java编程多线程之共享数据代码详解的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题,如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!