黑马程序员——Java语言多线程

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

一、多线程

1.1 线程

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

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

理解线程：

1. 一个进程中至少有一个线程

2. JVM 启动的时候会有一个进程java.exe

该进程中至少有一个线程在负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称为主线程；同时还会启动垃圾回收线程。

3. 开启多个线程是为了同时运行多部分代码，每一个线程都有自己运行的内容，这个内容可以称为线程要执行的任务。

多线程的好处：解决了多部分代码同时运行的问题。

多线程的弊端：线程太多，会导致效率的降低。

1.2 创建线程

1.2.1 继承Thread类

创建方式：

1. 定义一个类继承Thread类。

2. 覆盖Thread类中的run方法。

3. 直接创建Thread的子类对象创建线程。

4. 调用start方法开启线程，该方法有两个作用，启动线程，调用run方法。

为什么要覆盖run方法?

Thread 类用于描述线程

该类定义了一个功能用于存储线程要运行的代码，就是run方法，run方法用于存储线程中要运行的代码

class Demo extends Thread 
{
	public void run()
	{
		System.out.println("demo run");
	}
}
class ThreadDemo 
{
	public static void main(String[] args)
	{
		Demo d = new Demo(); //创建好一个线程
		d.start();//开启线程并执行该线程的run方法
		//d.run()  仅仅是对象调用方法，主线程在运行它，新创建的进程没有运行
	}
}

P.S.

1、可以通过Thread的getName方法获取线程的名称，名称格式：Thread-编号（从0开始）。

2、Thread在创建的时候，该Thread就已经命名了。

1.2.2 实现Runnable 接口

创建方式：

1.定义类实现Runnable接口

2.覆盖Runnable接口中的run方法，将线程要运行的代码存放在run方法中

3.通过Thread类建立线程对象

4.将Runnable接口的子类对象作为实际参数传递给Tread类的构造函数

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

class ThreadDemo
{
	public static void main(String[] args) 
	{
		Thread t1 = new Thread(new Run());
		t1.start();
		for(int y=0;y<10;y++)
		{
			System.out.println(Thread.currentThread().getName()+"  y="+y);
		}
	}
}

class Run implements Runnable
{
	public void run()
	{
		for(int x=0;x<10;x++)
		{
			System.out.println(Thread.currentThread().getName()+"  x="+x);
		}
	}

}

每次运行打印的顺序都不一样。 

实现方式与继承方式有什么区别

继承Thread：线程代码存放在Thread子类run方法中

实现Runnable：线程代码存放在接口子类的run方法中

实现：避免类单继承的局限性，在定义线程时建议使用实现方式

实现Runnable接口的好处：

1. 将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。

2. 避免了Java单继承的局限性。 所以，创建线程的第二种方式较为常用。

1.3 线程的安全问题

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行到一部分，另一个线程参与进来，导致共享数据错误

解决办法：操作共享数据时，让一个线程执行完，其他线程再开始执行

1.3.1 java解决办法：同步代码块(锁)

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

同步的前提

1.必须有两个以上的线程

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

好处：解决了安全问题

弊端：需要判断锁，较为消耗资源

练习：实现一个卖票程序

class Ticket implements Runnable {
	public  int tic = 100;
	Object obj = new Object();
	public void run()
	{
		while(true)
		{
			synchronized(obj)
			{
				if(tic>0)
				{
				try
				{
				Thread.sleep(10);  //睡眠再去执行程序可能出现问题
				}
				catch(Exception e)
				{
					
				}
				System.out.println(Thread.currentThread().getName()+"..sale:"+tic--);
			}
			}
		}
	}
}

class ThreadTest1
{
	public static void main(String[] args)
	{
		Ticket t = new Ticket();
		
		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();		
	}
}

结果分析：

Object对象相当于是一把锁，只有抢到锁的线程，才能进入同步代码块向下执行。 因此，当tic=1时，CPU切换到某个线程后，如上图的Thread-3线程，其他线程将无法通过同步代码块继而进行if判断语句，只有等到Thread-3线程执行完“tic--” 操作（此后tic的值为0），并且跳出同步代码块后，才能抢到锁。 其他线程即使抢到锁，然而，此时tic值已为0，也就无法通过if语句判断，从而无法再执行“ tic--” 的操作了，也就不会出现0、 -1、 -2等情况了。

1.3.2 同步函数：用synchronized修饰操作共享数据的函数

练习：模拟银行存钱代码

class Bank
{
	private int sum;
	Object obj = new Object();
	public synchronized void add(int n)//同步函数
	{
		//synchronized(obj)
		//{
			sum = sum + n;
			System.out.println("sum="+sum);
		//}
	}
}
class Cun implements Runnable
{
	private Bank b = new Bank();
	public void run()
	{
		for(int x=0; x<3; x++)
		{
			b.add(100);
		}
	}
}


class ThreadTest2
{
	public static void main(String[] args)
	{
		Cun c = new Cun();
		Thread t1 = new Thread(c);
		Thread t2 = new Thread(c);
		t1.start();
		t2.start();
	}
}

同步函数和同步代码块的区别：

1. 同步函数的锁是固定的this。

2. 同步代码块的锁是任意的对象。

建议使用同步代码块。 

1.3.3 静态函数的同步

被静态修饰的同步函数，通过验证，使用的锁不是this，因为静态方法中也不可以定义this

静态的同步函数，使用的锁是该方法所在类的字节码文件对象：类名.class

多线程下的单例模式，饿汉式不存在安全问题，懒汉式的安全问题可以如下解决

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;
		
	}
}

class SingleDemo
{
	public static void main(String[] args)
	{
		Single s = Single.getInstance();
	}
}

1.3.4 死锁

死锁常见情景之一：同步的嵌套

//定义一个类来实现Runnable，并复写run方法
/*
死锁：同步中嵌套同步

*/

class Test implements Runnable
{
	private boolean flag;
	Test (boolean flag)
	{
		this.flag = flag;
	}
	public void run()
	{
		if(flag)
		{
			synchronized(mylock.obj1)
			{
				System.out.println("if obj1");
				synchronized(mylock.obj2)
				{
					System.out.println("if obj2");
				}
			}
		}
		else
		{
			synchronized(mylock.obj2)
			{
				System.out.println("else obj2");
				synchronized(mylock.obj1)
				{
					System.out.println("else obj1");
				}
			}
		}			
		
	}
}

class mylock
{
	static Object obj1 = new Object();
	static Object obj2 = new Object();
}

class DeadLockTest
{
	public static void main(String[] args)
	{
		Thread t1 = new Thread(new Test(true));
		Thread t2 = new Thread(new Test(false));
		t1.start();
		t2.start();
		
	}
}

程序处于等待状态，形成死锁

1.4 线程间的通讯

多个线程在处理统一资源，但是任务却不同，这时候就需要线程间通信。

等待/唤醒机制涉及的方法：

1. wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中。

2. notify()：唤醒线程池中的一个线程（任何一个都有可能）。

3. notifyAll()：唤醒线程池中的所有线程

注意：

1、这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法。

2、必须要明确到底操作的是哪个锁上的线程！

3、wait和sleep区别？

1）wait可以指定时间也可以不指定。sleep必须指定时间。

2）在同步中时，对CPU的执行权和锁的处理不同。

wait：释放执行权，释放锁。

sleep：释放执行权，不释放锁。

1.5 JDK1.5新特性

同步代码块就是对于锁的操作是隐式的。

JDK1.5以后将同步和锁封装成了对象，并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了

显示动作。

Lock接口：出现替代了同步代码块或者同步函数，将同步的隐式操作变成显示锁操作。同时更为灵

活，可以一个锁上加上多组监视器。

lock()：获取锁。

unlock()：释放锁，为了防止异常出现，导致锁无法被关闭，所以锁的关闭动作要放在finally中。

Condition接口：出现替代了Object中的wait、notify、notifyAll方法。将这些监视器方法单独进行了

封装，变成Condition监视器对象，可以任意锁进行组合。

Condition接口中的await方法对应于Object中的wait方法。

Condition接口中的signal方法对应于Object中的notify方法。

Condition接口中的signalAll方法对应于Object中的notifyAll方法

/*
生产者生产商品，供消费者使用
有两个或者多个生产者，生产一次就等待消费一次
有两个或者多个消费者，等待生产者生产一次就消费掉
*/

import java.util.concurrent.locks.*;

class Resource 
{	
	private String name;
	private int count=1;
	private boolean flag = false;
	
	//多态
	private Lock lock=new ReentrantLock();

	//创建两Condition对象，分别来控制等待或唤醒本方和对方线程
	Condition condition_pro=lock.newCondition();
	Condition condition_con=lock.newCondition();

	//p1、p2共享此方法
	public void setProducer(String name)throws InterruptedException
	{
		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();//唤醒对方
		}
		finally
		{
			lock.unlock();//解锁，这个动作一定执行
		}
		
	}

	//c1、c2共享此方法
	public void getConsumer()throws InterruptedException
	{
		lock.lock();
		try
		{
			while(!flag)//重复判断标识，确认是否可以消费
				condition_con.await();

			System.out.println(Thread.currentThread().getName()+".消费."+this.name);//打印消费
			flag=false;//控制生产\消费标识
			condition_pro.signal();
		}
		finally
		{
			lock.unlock();
		}

	}
}

//生产者线程
class Producer implements Runnable 
{
	private Resource res;
	Producer(Resource res)
	{
		this.res=res;
	}
	//复写run方法
	public void run()
	{
		while(true)
		{
			try
			{
				res.setProducer("商品");
			}
			catch (InterruptedException e)
			{
			}
		}
	}
}

//消费者线程
class Consumer implements Runnable
{
	private Resource res;
	Consumer(Resource res)
	{
		this.res=res;
	}
	//复写run
	public void run()
	{
		while(true)
		{
			try
			{
				res.getConsumer();
			}
			catch (InterruptedException e)
			{
			}
		}
	}

}

class  ProducerConsumer
{
	public static void main(String[] args) 
	{
		Resource res=new Resource();

		new Thread(new Producer(res)).start();//第一个生产线程 p1
		new Thread(new Consumer(res)).start();//第一个消费线程 c1

		new Thread(new Producer(res)).start();//第二个生产线程 p2
		new Thread(new Consumer(res)).start();//第二个消费线程 c2
	}
}

1.6 停止线程

如何停止线程？

只有一种方法，run方法结束。

启动多线程运行，运行代码通常是循环结构只要控制循环，就可以让run方法结束，也就是线程结束。

特殊情况：

当线程处于冻结状态，就不会读取到标记，那么线程就不会结束。

当没有指定的方式让冻结的线程回复到运行状态时，就需要对冻结进行清除，强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束interrupt()。

class StopThread implements Runnable
{
	private boolean Flag = true;
	public void run()
	{
		while(Flag)
		{
			System.out.println(Thread.currentThread().getName()+"..run");
		}
	}
	public void changeFlag()
	{
		Flag = false;
	}
}

class StopThreadDemo
{
	public static void main(String[] args)
	{
		StopThread st = new StopThread();
		
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);
		
		t1.setDaemon(true);
		t2.setDaemon(true);
		
		t1.start();
		t2.start();
		
		int num = 0;
		
		while (true)
		{
			if(num++ == 60)
			{
	
				break;
			}
			
			System.out.println(Thread.currentThread().getName()+"..."+num);
		}
		
	}
}

1.7 操作线程的其他方法

class Demo implements Runnable
{
	public void run()
	{
		for(int x=0; x<70; x++)
		{
			System.out.println(Thread.currentThread().toString()+"...."+x);
			Thread.yield();//暂停当前正在执行的线程对象，并执行其他线程，可以是线程交替运行
			
		}
	}
}

class JoinDemo
{
	public static void main(String[] args)  throws Exception
	{
		Demo d = new Demo();
		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
			
		t1.start();
		//t1.join(); t1要求加入运算，主线程释放运算权，直到t1结束，
		 		 //主线程开始执行下面的代码，t2开始执行
		
		t2.start();
		t2.setPriority(Thread.MAX_PRIORITY);
		//t1.join(); //join 要求加入运算,主线程释放执行权
					//此时t1与t2交替运行，直到t1运算结束，主线程开始执行
		
		for(int x=0; x<80; x++)
		{
			System.out.println("main..."+x);
		}
			
		System.out.println("over");
	}
}

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

2、setPriority（）方法用来设置优先级

        MAX_PRIORITY 最高优先级10

        MIN_PRIORITY   最低优先级1

        NORM_PRIORITY 分配给线程的默认优先级

3、yield（）方法可以暂停当前线程，让其他线程执行。