Java之多线程，并发(含图解，代码案例)【JAVA基础】

最新推荐文章于 2024-08-28 10:25:48 发布

liudachu

最新推荐文章于 2024-08-28 10:25:48 发布

阅读量3.5k

点赞数 2

分类专栏： Java笔记文章标签：多线程 java 面试并发编程 jvm

本文链接：https://blog.csdn.net/liudachu/article/details/105379448

版权

Java笔记专栏收录该内容

31 篇文章 2 订阅

订阅专栏

图片来源网络

`多线程`

进程：是一个正在执行中的程序。
每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

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

一个进程中至少有一个线程。

Java jvm（虚拟机）启动的时候会有一个进程java.exe
该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中
该线程称之为主线程。

扩展：更细节说明虚拟机jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。

java已经提供了对线程这类事物的描述，就是Thread类。

一、创建线程的第一种方式：继承Thread类。
步骤：
1.定义继承Thread类
2.复写Thread类中的run方法（Thread类中的run方法，用于存储线程要运行的代码）
目的：将自定义的代码存储在run方法中，让线程运行。
3.调用线程的start方法，
该方法两个作用，启动线程，调用run方法。

  getName()  获取线程名称
  setNmae()  设置线程名称
  static Thread currentThread()  返回当前正在运行的线程的引用

二、创建线程的第二种方式，实现Runnable接口
步骤：
1.定义类实现Runnable接口
2.覆盖Runnable接口中的run方法
将线程要运行的代码存放在该run方法中
3.通过Thread类建立线程对象。
4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
为什么要将Runnable接口的子类对象传递给Thread的构造函数。
因为，自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去指定指定对象的run方法，就必须明确该run方法所属的对象。
5.调用Thread类的start方法开启线程并调用Runnable接口子类run方法。

实现方式和继承方式的区别
实现方式好处：避免了单继承的局限性。
在定义线程时，建议使用实现方式。

两种方式区别：
继承Thread:线程代码存放Thread子类run方法中。
实现Runnaable,线程代码存放接口的子类run方法中。

多线程运行的`安全问题`

问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。
另一个线程参与进来执行，导致共享数据的错误。
解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中其他线程不可以参与执行。
Java对多线程的安全问题提供了专业的解决方式，就是
1.同步代码块

   syschronized(对象)
   {
     需要被同步的代码
   }

对象如同锁，持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
 
 同步的前提：
 1.必须要有两个或者两个以上的线程。
 2.必须是多个线程使用同一个锁。
 好处：解决了多线程的安全问题。
 弊端：多个线程需要判断锁，较为消耗资源。

2.同步函数
public synchronized void show(){}
寻找安全问题的代码：
1.明确哪些代码是多线程运行代码。
2.明确共享数据
3.明确多线程运行代码中那些语句是操作共享数据的。

注意：
1.函数需要被对象调用，那么函数都有一个所属对象引用么就是this.
    所以同步函数使用的锁是this。
2.静态的同步函数，使用的锁是该方法所在类的字节码文件  类名.class
    静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。
         -类名.class  该对象的类型是class

JDK1.5 中提供了多线程升级解决方案

将同步Synchronized替换成显示Lock操作
将Object中的wait，notify,notifyAll,替换成了Condition对象
该对象可以用Lock锁进行获取
该示例，实现了本方值唤醒对方操作

先来说说它跟synchronized有什么区别吧，Lock是在Java1.6被引入进来的，Lock的引入让锁有了可操作性，什么意思？就是我们在需要的时候去手动的获取锁和释放锁，甚至我们还可以中断获取以及超时获取的同步特性，但是从使用上说Lock明显没有synchronized使用起来方便快捷。我们先来看下一般是如何使用的：

private Lock lock = new ReentrantLock(); // ReentrantLock是Lock的子类

   private void method(Thread thread){
       lock.lock(); // 获取锁对象
       try {
           System.out.println("线程名："+thread.getName() + "获得了锁");
           // Thread.sleep(2000);
       }catch(Exception e){
           e.printStackTrace();
       } finally {
           System.out.println("线程名："+thread.getName() + "释放了锁");
           lock.unlock(); // 释放锁对象
       }
   }

死锁

同步中嵌套同步，锁不同。

所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。

死锁产生的原因

1.竞争不可抢占性资源
　　p1已经打开F1，想去打开F2，p2已经打开F2，想去打开F1，但是F1和F2都是不可抢占的，这是发生死锁。

2.竞争可消耗资源引起死锁
　　进程间通信，如果顺序不当，会产生死锁，比如p1发消息m1给p2，p1接收p3的消息m3，p2接收p1的m1，发m2给p3，p3，以此类推，如果进程之间是先发信息的那么可以完成通信，但是如果是先接收信息就会产生死锁。

3.进程推进顺序不当
　　　　进程在运行过程中，请求和释放资源的顺序不当，也同样会导致产生进程死锁。

如何避免死锁

破坏死锁产生的四个必要条件之一即可

资源一次性分配：一次性分配所有资源，这样就不会再有请求了：（破坏请求条件）
只要有一个资源得不到分配，也不给这个进程分配其他的资源：（破坏请保持条件）
可剥夺资源：即当某进程获得了部分资源，但得不到其它资源，则释放已占有的资源（破坏不可剥夺条件）
资源有序分配法：系统给每类资源赋予一个编号，每一个进程按编号递增的顺序请求资源，释放则相反（破坏环路等待条件）

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

   唤醒机制:
   wait();           这些操作都使用在同步中，因为要对持有监视器（锁）的线程操作。
   notify();         等待和唤醒必须是同一把锁。
   notifyAll();

Thread中的方法
join()：
当A线程执行到了B线程的.join()方法时,A就会等待，等B线程都执行完，A才会执行
join可一用来临时加入线程执行。

setPriority():
设置优先级。
setPriority(Thread.MAX_PRIORITY)//最高优先级
setPriority(Thread.MIN_PRIORITY)//最低优先级
yield()

多线程`案例`

案例一：

package 黑马多线程;
/*
 * 需求：简单的卖票程序
 * 多个窗口同时买票。
 */
public class SaleTicket {
	public static void main(String[] args) {
		Ticket t1=new Ticket();
		Ticket t2=new Ticket();
		Ticket t3=new Ticket();
		Ticket t4=new Ticket();
		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}
}
class Ticket extends Thread
{
	private static int tick=100;//static 让四个线程共享一个数据
	public void run()
	{
		while(true)
		{
			if(tick>0)System.out.println(currentThread().getName()+"...sale"+tick--);
		}
	}
}

案例二：

package 黑马多线程;
/*
* 需求：简单的卖票程序2
* 多个窗口同时买票。
* 
* 创建线程的第二种方式，实现Runnable接口
* 步骤：
* 1.定义类实现Runnable接口
* 2.覆盖Runnable接口中的run方法
*   将线程要运行的代码存放在该run方法中
* 3.通过Thread类建立线程对象。
* 4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
*   为什么要将Runnable接口的子类对象传递给Thread的构造函数。
*   因为，自定义的run方法所属的对象是Runnable接口的子类对象。
*   所以要让线程去指定指定对象的run方法，就必须明确该run方法所属的对象。
* 5.调用Thread类的start方法开启线程并调用Runnable接口子类run方法。
*/
public class SaleTicket2 {
	public static void main(String[] args) {
		Ticket2 t=new Ticket2();
		
		Thread t1=new Thread(t);
		Thread t2=new Thread(t);
		Thread t3=new Thread(t);
		Thread t4=new Thread(t);		
		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}
}
class Ticket2 implements Runnable
{
	private int tick=100;
	public void run()
	{
		while(true)
		{
			if(tick>0)
			{				
				System.out.println("...sale"+tick--);
			}
		}
	}
}

线程间的通讯案例：

package 黑马多线程;
//线程间的通讯-------生产者消费
/*
 * 对于多个生产者和消费者
 * 定义while判断标记：让被唤醒的线程再一次判断标记
 * 定义notifyAll()：使用notify，容易出现只唤醒本方线程的情况，导致所有线程都等待
 * */
public class ProducerConsumDemo {
	public static void main(String[] args) {
		Resource r=new Resource();
		
		Producer pro=new Producer(r);
		Consumer con=new Consumer(r);
		
		new Thread(pro).start(); 
		new Thread(pro).start(); 
		new Thread(con).start(); 
		new Thread(con).start(); //--------两个输入线程，两个输出线程
		

	}
}
class Resource//---资源
{
	private String name;
	private int count=1;
	private boolean flag=false;
	
	public synchronized void set(String name) {
		while(flag)//--------------while次线程被唤醒都进行判断
			try {wait();}catch(Exception e){}
		this.name=name+"--"+count++;
		System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
		flag=true;
		this.notifyAll();//------------线程全部唤醒
	}
	public synchronized void out() {
		while(!flag)//--------------while每次线程被唤醒都进行判断
			try {wait();}catch(Exception e){}
		System.out.println(Thread.currentThread().getName()+"...消费者.。.."+this.name);
		flag=false;
		this.notifyAll();
	}
}

class Producer implements Runnable//--生产者
{
	private Resource res;
	Producer(Resource res)
	{
		this.res=res;
	}
	public void run()
	{
		while(true)
		{
			res.set("+商品+");
		}
	}
}

class Consumer implements Runnable//--消费者
{
	private Resource res;
	Consumer(Resource res)
	{
		this.res=res;
	}
	public void run()
	{
		while(true)
		{
			res.out();
		}
	}
}

线程间的通讯案例（升级版）：

package 黑马多线程;

import java.util.concurrent.locks.*;

//线程间的通讯-------生产者消费2---jdk5.0升级版
/*
 * 对于多个生产者和消费者
 * 定义while判断标记：让被唤醒的线程再一次判断标记
 * 定义notifyAll()：使用notify，容易出现只唤醒本方线程的情况，导致所有线程都等待
 * 
 * JDK1.5 中提供了多线程升级解决方案
 * 将同步Synchronized替换成显示Lock操作
 * 将Object中的wait，notify,notifyAll,替换成了Condition对象
 * 该对象可以用Lock锁 进行获取
 * 该示例 ，实现了本方值唤醒对方操作
 * */
public class ProducerConsumDemo2 {
	public static void main(String[] args) {
		Resource2 r=new Resource2();
		
		Producer2 pro=new Producer2(r);
		Consumer2 con=new Consumer2(r);
		
		new Thread(pro).start(); 
		new Thread(pro).start(); 
		new Thread(con).start(); 
		new Thread(con).start(); //--------两个输入线程，两个输出线程
		

	}
}
class Resource2//---资源
{
	private String name;
	private int count=1;
	private boolean flag=false;
	private Lock lock=new ReentrantLock();
	private Condition condition_pro=lock.newCondition();//生产者
	private Condition condition_con=lock.newCondition();//消费者
	
	public void set(String name)throws InterruptedException {
		lock.lock();
		try
		{
		while(flag)//--------------while次线程被唤醒都进行判断
			condition_con.await();
		this.name=name+"--"+count++;
		System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
		flag=true;
		condition_pro.signal();
		}
		finally 
		{
		lock.unlock();//释放锁的动作一定要执行
		}
	}
	public void out()throws InterruptedException {
		lock.lock();
		try 
		{
		while(!flag)//--------------while每次线程被唤醒都进行判断
			condition_pro.await();
		System.out.println(Thread.currentThread().getName()+"...消费者.。.."+this.name);
		flag=false;
		condition_con.signal();
		}
		finally {
			lock.unlock();
		}
	}
}

class Producer2 implements Runnable//--生产者
{
	private Resource2 res;
	Producer2(Resource2 res)
	{
		this.res=res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
			res.set("+商品+");
			}
			catch(InterruptedException e)
			{
				
			}
		}
	}
}

class Consumer2 implements Runnable//--消费者
{
	private Resource2 res;
	Consumer2(Resource2 res)
	{
		this.res=res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
			res.out();
			}
			catch(InterruptedException e)
			{
				
			}
		}
	}
}

多线程–单例设计模式–懒汉式

package 黑马多线程;
//多线程--单例设计模式--懒汉式

/*
//饿汉式
class Single
{
	private static final Single s=new Single();
	private Single() {}
	public static Single getInstance()
	{
		return s;
	}
}
*/

//懒汉式
class Single
{
	private static Single s=null;
	private Single() {}
	public static Single getInstance()
	{
		if(s==null) //-----------------提高懒汉式的效率
		{
		    synchronized(Single.class) //---------提高懒汉式的安全性
		    {
		        if(s==null)
			       s=new Single();		
		     }
		}
		return s;
	}
}

public class SynchronizedDemo3 {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根

	}
}