『Java』多线程+线程通讯

最新推荐文章于 2021-10-03 10:03:30 发布

DarkHorseJack

最新推荐文章于 2021-10-03 10:03:30 发布

阅读量748

点赞数

分类专栏： JavaBase[Java基础回顾] 文章标签：多线程通讯线程设计模式

本文链接：https://blog.csdn.net/jackplp/article/details/17534171

版权

JavaBase[Java基础回顾] 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

多线程在实际开发中无处不在,处处都在,具有着高性能批量操作多处理等优点

进程:是一个正在执行中的程序,每一个进程都有一个执行顺序,该顺序是一个执行路径,或者叫一个控制单元(一个进程中至少有一个线程)

线程:就是进程中的一个独立的控制单元,线程控制着进程的执行

那么,如何在自己定义的代码中,自定义一个线程?

第一种方式:继承Thread类

>1,定义类继承Thread >2,复写run方法 >3,调用线程的start方法(启动线程并调用run方法)

为什么要覆盖run方法?Thread类用于描述线程.该类就定义了一个功能[run]用于存储线程要运行的代码.

第二种方式:实现Runnable接口

>1,定义类实现Runnable接口>2,覆盖Runnable接口中的run方法>3,通过Thread类建立线程对象

>4,将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数,为了让线程去执行制定的run方法,明确该run方法的所属对象

>5,调用Thread类中的start方法开启线程并调用Runnable接口子类的run方法

两种方式都能创建,实现方式和继承方式又有什么区别?

避免了单继承的局限性.区别:线程代码存放位置不同.继承存放在Thread子类的run方法中.而实现则是存放在Runnable接口的子类run方法中.

线程运行时的状态:

多线程安全问题:

问题原因,当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,

还没执行完,别一个线程也参与进来执行,导致共享数据的错误.

解决办法:对多调操作共享数据的语句,控制,只能让一个线程都执行完毕后,再让其他线程参与.

java对多线程安全问题提供了专业的解决方式>>>同步代码快

Synchronized(对象){ //对象如同一把锁,持有锁的线程可以在同步中执行.

需要被同步的代码

}

同步的前提:1,必须要有两个或两个以上的线程

2,必须是多个线程使用同一个锁

好处:解决多线程的安全问题.弊端:多个线程需要判断锁,比较消耗资源

如何找多线程中存在的安全问题?

1,明确哪些代码是多线程运行的代码run()里的全是

2,明确共享数据[一般成员都是]

3,明确多线程运行代码中哪些语句是操作共享数据的

同步函数:

函数返回值前加上Synchronized,即可[他使用的锁是,this]

如果同步函数被static静态修饰后,使用的锁为,该类对应的字节码文件对象[类名.class]唯一性

Synchronized的应用延迟加载单例模式:

public class Test7 {
	public static void main(String[] args){//建立Main函数，用来验证单例模式
		System.out.println("第7题：编写一个延迟加载的单例设计模式?");
		System.out.println("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
		
		
		//建立s对象（其实，是将唯一对的引用赋给他s）
		singleLhs s=singleLhs.getInstance();
		System.out.println("s对象下调用的num值："+s.Getnum());//先获取num
		//在s下对num进行赋值操作
		System.out.println("s对象下将num赋值为：“1314”");
		s.Setnum(1314);
		//建立ss对象（其实，还是将那个唯一对象的引用赋值给ss）
		singleLhs ss=singleLhs.getInstance();
		//在ss下获取并打印num，num的值依旧还是没有被初始化。还是被s下修改后的num。
		System.out.println("ss对象下调用的num值："+ss.Getnum());
		
		
		System.out.println("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
		System.out.println("老师由次看来，我写的延迟加载单例设计模式成功了。");
		System.out.println("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
	}


}
//建立单例类
class singleLhs{
	private int num=100;//定义一个被私有化的成员变量来，测试，单例模式。
	public int Getnum(){//建立获取num的方法
		return num;
	}
	public void Setnum(int num){//建立设置num的方法
		this.num=num;//用到this关键字，在这主要为解决成员变量与局域变量重名的问题。this指的是当前对象的引用。
	}
	private static singleLhs sLhs=null;//
	private singleLhs(){}//私有化构造函数，单例模式的核心，只要私有了它，就不能给对象初始化，就能控制随意新建对象了。
	public static singleLhs getInstance(){//建立获取这个唯一对象的方法。
		//使用双重if判断，可以解决懒汉式中同步的效率问题。
		if(sLhs==null){//首先判断
			synchronized(singleLhs.class){//同步时，使用的锁为，该类所属的字节码文件对象。
				if(sLhs==null){//再次判断，设置关卡
					sLhs=new singleLhs();//成功建立唯一的对象
				}
				
			}
		}
		return sLhs;
	}
	
	
	
	
	
	
}

多线程间的通讯:其实就是多个线程在操作一个资源,但操作的动作不同

等待唤醒机制:

wait(),notify(),notifyAll()

都使用在同步中,因为要对持有监视器(锁)的线程操作

所以要使用在同步中,因为只有同步才具有锁

例子:

class Res
{
	private String name;//定义名字
	private String sex;//定义性别
	private boolean flag=false;//定义标识,旗帜
	public synchronized void set(String name,String sex){//定义方法接受数据
			if(flag)//如果为真,代表有数据没输出,需要等待
				try{this.wait();}catch(Exception e){}
			this.name=name;
			this.sex=sex;
			flag=true;录入完数据,标识可以输出
			this.notify();激活线程们
	}
	public synchronized void out(){//定义输出方法,将数据逐个输出
		if(!flag)//判断是否有数据没有,则睡觉
			try{this.wait();}catch(Exception e){}	
		System.out.println(name+"........."+sex);
		flag=false;//取完数据,把旗帜表示为空,代表数据取走可以录入
		this.notify();//激活线程
	}
}
class Input implements Runnable//实现Runnable来自定义多线程
{
	//资源对象
	private Res r;
	//构造函数，传进来一个对象，将引用赋给r
	Input(Res r)
	{
		this.r=r;
	}
	public void run()//复写run,将多线程执行代码写入
	{
		int x=0;
		while(true)
		{
			if(x==0)
					r.set("mike","man");
		  
		  else
					r.set("丽丽","女");
			
			x=(x+1)%2;
		}
		
	}
	
}
class Output implements Runnable//输出
{
			private Res r;
			Output(Res r){
				this.r=r;
			}
			public void run(){
				while(true){
					r.out();
				}
			
			}
	
}
class Duoxc//测试
{
	public static void main(String[] args){
		Res r=new Res();
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();
	}
}

这些操作方法都定义在Object中,又为什么?

因为这些方法在操作同步中线程时,都必须要标识他们所操作线程持有的锁,只有同一个锁上的被等待线程,才可以被同一个锁上的notify唤醒,不可以对

不同锁上的线程进行唤醒.锁可以是任意对象,所以可以被任意对象调用的方法一定要定义在Object类中.

Jdk1.5升级,里程碑,版本标识这从5.0走起,同时也给我们带来了许多神方法

在jdk1.5中,提供了多线程升级解决方案

lock,显示的锁机制

将同步Synchronized替换成显示lock操作.[显示的锁机制],其中将Object中的wait,notify,notifyAll,替换成了.condition对象.该对象通过lock锁获取.

在java.util,concurrent.locks中.一个锁可对应多个,支持多个相关的condition

lock实例:

import java.util.concurrent.locks.*;

class ProducerConsumerDemo//测试
{
	public static void main(String [] args){
		Resource r=new Resource();//实例化资源
		
		Producer pro=new Producer(r);//实例化输入数据
		Consumer con=new Consumer(r);//实例化输出数据
		
		Thread t1=new Thread(pro);//建立多线程
		Thread t2=new Thread(pro);//建立多线程
		Thread t3=new Thread(con);//建立多线程
		Thread t4=new Thread(con);//建立多线程
		
		t1.start();//调用start方法启动线程
		t2.start();
		t3.start();
		t4.start();
	
	
	
	
	}
	
	
	
	
}

class Resource//资源类
{
	private String name;//定义名字
	private int count=1;//计量器
	private boolean flag=false;//旗帜,做标识
	private Lock lock=new ReentrantLock();//建立lock
	Condition condition_pro=lock.newCondition();//一个锁支持多个condition
	Condition condition_con=lock.newCondition();//一个锁支持多个condition
	
	public  void set(String name){//数据录入
		lock.lock();//加锁
		try{
			while(flag)//判断标识,如果有数据,则等会在录入
			condition_pro.await();
			this.name=name+"&"+count++;
		System.out.println(Thread.currentThread().getName()+"********制造**********"+this.name);
		flag=true;//数据录入完毕,标识旗帜
		condition_con.signal();//唤醒对方输出线程
	}catch(Exception e){}
		finally{
			lock.unlock();//最终关掉线程
		}
	}
	public void out(){
			lock.lock();//加锁
		  try{
				
		while(!flag)//判断旗帜,有数据就输出,没有就等会
			condition_con.await();
			System.out.println(Thread.currentThread().getName()+"--销售---"+this.name);
			flag=false;//输出完后,改下旗帜.标识已经清空
			condition_pro.signal();唤醒对方,录入线程
		}catch(Exception e){}
		finally{
			lock.unlock();//最终关掉锁
		}
			
	}
	
	
}
class Producer implements Runnable//实现Runnable复写run建立多线程执行代码
{
	Resource res;
	Producer(Resource res){
		this.res=res;
	}
	public void run(){
	while(true)//循环录入
		res.set("商品");
	}
}
class Consumer implements Runnable//实现Runnable复写run建立多线程执行代码
{
	Resource res;
	Consumer(Resource res){
		this.res=res;
	}
	public void run(){
	while(true)//循环取出
			res.out();
		}
}

停止线程[stop已经过时,该怎么办?]

1,定义循环结束标记

停止线程,只有一种,run方法结束.在线程运行代码中,大都是循环,只要能控制住循环即可.

2,使用interrupt(终端)方法

特殊情况下,当线程处于冻结状态,就不会取到标记.此时就需要用该方法结束线程的冻结状态,使线程回到运行状态.

新增的一些方法:

守护线程setDaemon(boolean)

该方法必须在启动线程前调用,将该线程标记为守护线程或用户线程,当正在运行的线程都为守护线程时,java虚拟机会退出

join()方法

当A线程执行到B线程的B.join() 方法时,A就会等待,等B线程都执行完成后,A线程才会执行,在他身后默默的守候.

String tostring()

返回该线程的字符串表示形式,包括线程名称,优先级,和线程组

优先权setPriorty(int newPriority)更改线程的优先级,默认为5,一共分为(1~10)

MIN_PRIORITY最低 MORM_PRIORITY默认 MAX_PRIORITY最高

static void yield()

暂停当前正在执行的线程,并执行其他线程

DarkHorseJack

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
『Java』多线程+线程通讯

多线程在实际开发中无处不在,处处都在,具有着高性能批量操作多处理等优点进程:是一个正在执行中的程序,每一个进程都有一个执行顺序,该顺序是一个执行路径,或者叫一个控制单元(一个进程中至少有一个线程)线程:就是进程中的一个独立的控制单元,线程控制着进程的执行
复制链接

扫一扫