黑马程序员——java 多线程

------- android培训、java培训、期待与您交流！ ----------

多线程

1、进程和线程

进程：运行中的应用程序称为进程，拥有系统资源（CPU、内存）。

线程：进程中的一个独立控制单元，一个进程可以有多个线程。本身不拥有资源（共享所在进程的资源）。

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

多进程：在同一个操作系统运行多个任务。

多线程：在同一个应用程序中有多个功能流同时运行。

多线程的意义：

（1）可以实现程序的并发执行效果，提高系统性能。

（2）在多线程中可以通过优先级管理，使重要的程序优先执行，提高CPU的处理效率。

（3）在多CPU系统中，可以把不同的线程在不同的CPU中执行，真正做到处理多任务。

2、创建线程方式一：继承Thread类

步骤：

（1）定义类继承Thread类。

（2）子类复写Thread中的run()方法，将线程运行的代码放到run()方法中。

（3）创建线程：建立子类对象的同时线程也就被创建了。

（4）通过调用start()开启线程。

示例：

class Demo extends Thread
{
	public void run()
	{
		for(int x=0; x<60; x++)
			System.out.println("demo run---"+x);
	}
}

class ThreadDemo 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();//创建好一个线程。
		d.start();//开启线程并执行该线程的run方法。

		//d.run();//仅仅是对象调用方法。创建了线程，但线程没有启动。
		
		for(int x=0; x<60; x++)
			System.out.println("主线程---"+x);			
	}
}

3、线程的四种状态

被创建：线程对象已经产生，但是尚未被启动。
运行：线程正在运行中。
冻结：由于某种原因（sleep或wait）导致真在运行的线程让出CPU并暂停自己的执行。
消亡：这个状态下表示该线程的run方法已经已经执行完毕了，已经相当于死亡了。

4、创建线程的方式二：实现Runable接口

步骤：

（1）定义类实现Runnable接口。

（2）复写Runnable接口中的run方法，将线程要运行的代码存放在该run方法中。

（3）通过Thread类建立线程对象。

（4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

思考：为什么要将Runnable接口的子类对象传递给Thread的构造函数？

因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run方法，就必须明确该run方法所属对象。

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

示例：

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

class  TicketDemo
{
	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();
	}
}

重点：实现方式的好处是：避免了单继承的局限性（在定义线程时，建立使用实现方式）。

两种方式区别：

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

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

5、线程安全问题

导致安全问题出现的原因：

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

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。对此Java提供了一种专业解决方式，即同步代码块。

同步代码块格式：

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

对象如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

示例：

class Ticket implements Runnable
{
	private  int tick = 1000;
	Object obj = new Object();
	public void run()
	{
		while(true)
		{
			synchronized(obj)//同步代码块，相当于加锁
			{
				if(tick>0)
				{
					try{Thread.sleep(10);}catch(Exception e){}//特意使程序出现不安全状况
					System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
				}
			}
		}
	}
}

class  TicketDemo2
{
	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();
	}
}

同步的前提：

（1）必须要有两个或者两个以上的线程。

（2）必须是多个线程使用同一个锁。

同步的好处：解决了多线程的安全问题。

同步的弊端：多个线程需要判断锁，较为消耗资源。

6、同步函数

格式：

在函数上加上synchronized修饰符即可。

示例：

class Ticket implements Runnable
{
	private  int tick = 100;
	public void run()
	{
		while(true)
		{
			show();//调用同步函数
		}
	}
	public synchronized void show()//同步函数
	{	
		if(tick>0)
		{
			try{Thread.sleep(10);}catch(Exception e){}
			System.out.println(Thread.currentThread().getName()+"...sale : "+ tick--);
		}
	}
}

class  TicketDemo
{
	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);
		t1.start();//开启线程
		t2.start();
		t3.start();
	}
}

思考：同步函数用的是哪个锁呢？

分析：函数需要被对象调用，那么函数都有一个所属对象引用，就是this。
结论：同步函数使用的锁是this。

如果同步函数被静态修饰后，使用的锁是什么呢？

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

7、线程间通信

示例：

生产消费商品：多个线程生产商品，多个线程消费商品。

要求：生产一个商品，就消耗一个商品。

class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;

	public synchronized void set(String name)
	{
		while(flag)//让被唤醒的线程再一次判断flag。
			try{this.wait();}catch(Exception e){}
		this.name = name+"--"+count++;

		System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
		flag = true;
		this.notifyAll();//唤醒对方线程，因为只用notify时，容易出现只唤醒本方线程，
				//对方线程未唤醒而导致程序中所有线程都等待。
	}
 
	public synchronized void out()
	{
		while(!flag)
			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();
		}
	}
}
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();//启动线程
		t2.start();
		t3.start();
		t4.start();
	}
}

思考1：wait()，notify()，notifyAll()用来操作线程，为什么不定义在Thread类中而定义在Object类中？

（1）这些方法都使用在同步中，因为要对持有监视器（锁）的线程操作，所以都使用在同步中（只用同步才具有锁）。

（2）这些方法在操作同步中线程时，都必须要标识它们所属同步的锁。

（3）锁可以是任意对象，所以任意对象调用的方法一定定义在Object类中。

思考2：wait()，sleep()有什么区别？

wait()释放CPU资源，释放锁。

sleep()释放CPU资源，不释放锁。