黑马程序员——多线程

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

线程是一个在进程基础上发展起来的概念，引入它是为了提高系统的并发执行程度，进一步减少时间和空间开销。简单来说，线程就是一个比进程更小的程序调度管理方式，一个进程中，可以有多个线程互相运行，以提高系统效率。

Java可以通过继承Thread类和实现Runable接口两种方式来创建线程，但是不管采用哪种方式都必须重写run()方法，也就是在run()方法中写入需要在新线程中执行的语句段。Run方法不能被直接调用，只能通过引用start()方法启动线程后，由start方法自动调用。

继承Thread类实现多线程示例：
package com.itheima.thread;

public class ThreadDemo {
	public static void main(String[] args) {
		Student student1 = new Student("线程一");
		Student student2 = new Student("线程二");
		student1.start();
		student2.start();

	}

}

class Student extends Thread {
	Student(String name) {
		super(name);

	}

	public void run() {

		System.out.println(Thread.currentThread().getName() + "开启");
	}

}
实现Runnable接口创建线程示例：  
package com.itheima.thread;

public class ThreadDemo {
	public static void main(String[] args) {
		Student student1 = new Student();
		Thread thread1 = new Thread(student1);
		Thread thread2 = new Thread(student1);
		
		thread1.start();
		thread2.start();

	}

}

class Student implements Runnable{
	
	public void run() {

		System.out.println(Thread.currentThread().getName() + "开启");
	}

}     

线程的生命周期主要分为几个状态：新建状态、就绪状态、运行状态、阻塞状态和终止状态。通过调用Thread类中的start()、sleep()、isAlive()、interrupt()等方法来完成生命周期的控制。

Java中可以调用setPriority()方法对线程设置优先级，其值必须在1~10之间，数值越大，优先级越高；需要注意的是，不能绝对依靠优先级来控制程序的逻辑正确性，使用优先级仅仅为了提高效率。

为了实现线程间的有机交替，并确保共享资源在某些关键时段只能被一个线程访问，即所谓的线程同步，java语言引入了对象互斥锁的概念。关键字synchronized用来与对象的互斥锁联系，可以用在对象前面限制一段代码的执行用在方法生命中，也可以用在方法前面，表示整个方法为同步方法。引入互斥锁之后，可能会出现死锁的现象，在java多线程机制中，没有指定检测和解决死锁问题的机制，需要编程人员在编写程序时就采取一些积极措施，防止多个线程对象出现死锁现象。

利用一个简单的模拟售票程序来演示线程的同步与死锁现象。
（1）没加synchronized的代码如下：
public class ThreadTest {
	public static void main(String[] args) {
		Buyticket buyticket = new Buyticket();
		Thread thread1 = new Thread(buyticket);
		thread1.setName("窗口1：");
		Thread thread2 = new Thread(buyticket);
		thread2.setName("窗口2：");
		thread1.start();
		thread2.start();
	}
}

class Buyticket implements Runnable {
	int ticket = 60;

	public void run() {
		while (true) {

			if (ticket > 0) {

				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {

				}
				System.out.println(Thread.currentThread().getName() + "卖出"
						+ ticket-- + "号票");

			}

		}

	}

}
该程序运行结果会出现0号票，而车票不能有0号票的存在，显然该程序的运行有安全隐患。
（2）加上synchronized同步后的代码：
  public class ThreadTest {
	public static void main(String[] args) {
		Buyticket buyticket = new Buyticket();
		Thread thread1 = new Thread(buyticket);
		thread1.setName("窗口1：");
		Thread thread2 = new Thread(buyticket);
		thread2.setName("窗口2：");
		thread1.start();
		thread2.start();
	}
}

class Buyticket implements Runnable {
	int ticket = 60;
	Object obj = new Object();

	public void run() {
		while (true) {
			synchronized (obj) {

				if (ticket > 0) {

					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {

					}
					System.out.println(Thread.currentThread().getName() + "卖出"
							+ ticket-- + "号票");

				}
			}
		}

	}

}
该程序的运行结果不会出现打印出0号车票的结果，显然加上synchronized同步后就解决了出现0号票的安全隐患。
（3）死锁的演示：
   
package com.itheima.thread;

public class ThreadTest {
	public static void main(String[] args) {
		Object obj1 = new Object();
		Object obj2 = new Object();
		Buyticket buyticket1 = new Buyticket(obj1,obj2);
		Buyticket buyticket2 = new Buyticket(obj2,obj1);
		
		Thread thread1 = new Thread(buyticket1);
		Thread thread2 = new Thread(buyticket2);
	
		thread1.start();
		thread2.start();
	}
}

class Buyticket implements Runnable {
	int ticket = 60;
	Object obj1 = new Object();
	Object obj2 = new Object();
   public Buyticket(Object obj1,Object obj2)
   {
	   this.obj1=obj1;
	   this.obj2=obj2;
   }
	public void run() {
       while(true)
			synchronized(obj1)
			{
				synchronized(obj2)
				{
					System.out.println(Thread.currentThread().getName()+" 拥有"+obj1+"等待"+obj2+":"+ticket--);
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
	}
}