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

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

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

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

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.必须是多个线程使用同一个锁。
 好处：解决了多线程的安全问题。
 弊端：多个线程需要判断锁，较为消耗资源。

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

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

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

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

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

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

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

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 自动生成的方法存根

	}
}

                                                      图片来源于网络