黑马程序员-----------------线程

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

线程：是指程序的执行流程，多线程的机制就是可以同时执行多个程序区块，这也就是是多线程存在的意义：并发。

//创建线程具有两种方式：继承Thread类，实现Runnable接口。

启动线程：在类中要想启动线程，应该准备好一下事项

1.定义类继承Thread类。

2.父类Thread类中的run方法。

3.调用线程的start方法，启动线程，调用run方法

代码演示：

//定义Demo类继承Thread类

class Demo extends Thread
{
	public void run()
	{
		System.out.println("Demo run!");
	}
}
public class ThreadDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Demo d = new Demo();
		d.start();//开启线程并执行该线程的run方法。
		d.run();//仅仅是对象调用方法，而线程创建了，并没有运行。
	}
}

重新编写上一段代码，使它可以同时启动多个线程

class Demo extends Thread
{
	private String name;
	Demo(String name)
	{
		this.name = name;
	}
	public void run()
	{
		for (int i = 0; i <5; i++) {
			System.out.println(name+"--------"+i);
		}
	}
}
public class ThreadDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//为了结果看上去更明显
		Demo d = new Demo("A");
		d.start();//开启线程并执行该线程的run方法。
		Demo d1 = new Demo("B");
		d1.start();//开启线程并执行该线程的run方法。
		Demo d2 = new Demo("C");
		d2.start();//开启线程并执行该线程的run方法。
	}
}

发现运行同一段代码每次的结果都是不同的：
因为多个线程都获取CPU的执行权，CPU执行到谁，谁就运行。明确一点，在某一个时刻，只能有一个程序在运行（多核除外），CPU在做着快速的切换，以达到看上去是同时运行的效果。我们可以形象把多线程的运行行为在互相抢夺CPU的执行权。

这就是多线程的一个特性：随机性，谁抢到谁执行

继承Thread类是线程创建的一种方式，线程创建的另一种方式时通过实现Runnable接口。

通过实现Runnable接口步骤：

1.定义类实现Runnable接口。

2.覆盖Runnable接口中的run方法。
3.通过Thread类建立线程对象。
4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

代码演示：

class RunnableTest implements Runnable
{
	private String name;
	RunnableTest(String name)
	{
		this.name = name;
	}
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i <5; i++) {
			System.out.println(name+"--------"+i);
		}
	}
}
public class RunnableDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		RunnableTest rt = new RunnableTest("A");//创建一个RunnableTest类对象rt
		Thread t1 = new Thread(rt);//创建线程对象t1
		t1.start();//启动t1线程
		RunnableTest rt1 = new RunnableTest("B");//创建一个RunnableTest类对象rt1
		Thread t2 = new Thread(rt1);//创建线程对象t2
		t2.start();//启动t2线程
		//rt.
	}
}

两种方式的区别：

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

线程生命周期：每一个线程，在其创建和销毁之前，都会具有4中状态之一：新建线程、可执行线程、被挂起线程、销毁线程

四种状态之间的转换可以用流程来表示就很清楚

线程在新创建的时候会进入到新创建线程这里面，通过线程调用start()启动线程，这是线程就正式启动进入可执行线程中，这时可执行的线程调用sleep(millis)或者wait()线程被挂起当，被挂起的线程sleep()结束或调用notify()方法时，线程变为可执行线程，可执行的线程调用stop()时线程结束。

class RTest
{
	public static void show()
	{
		for (int i = 0; i <5; i++) {
			try {
				Thread.sleep(10);//让线程休眠10毫秒
			} catch (InterruptedException e) {
			}
			System.out.println(Thread.currentThread()+"----"+i);
		}
	}
}
class RunnableTest implements Runnable
{
	public void run() {
		// TODO Auto-generated method stub
		RTest.show();
	}
}
public class RunnableDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		RunnableTest rt = new RunnableTest();//创建一个RunnableTest类对象rt
		Thread t1 = new Thread(rt);//创建线程对象t1
		t1.start();//启动t1线程
		RunnableTest rt1 = new RunnableTest();//创建一个RunnableTest类对象rt1
		Thread t2 = new Thread(rt1);//创建线程对象t2
		t2.start();//启动t2线程
		//rt.
	}
}

注意：因为sleep()方法会抛出InterruptedException异常，所以sleep()需要写在try---catch间

try {
	Thread.sleep(10);//让线程休眠10毫秒
}

 catch (InterruptedException e) {

}

线程安全问题：
利用同步代码块解决：
synchronized(对象){需要同步的代码 }
同步的前提：
1.必须要有两个或者两个以上的线程。、
2.必须是多个线程使用同一个锁。
同步好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源。

//有两个人每人具有300块去银行存钱，每人每次存入100块，多线程的同步方法实现小功能。

class Bank
{
	private int sum;
	//创建一个对象
	//Object obj = Object();
	public void add(int n)
	{
		synchronized(this)
		{
			sum = sum +n;
			try {
				Thread.sleep(10);
			} catch (InterruptedException e){
			}
			System.out.println("sum="+sum);
		}
	}
}
class Person implements Runnable
{
	private Bank b = new Bank();
	public void run() {
		for (int i = 0; i < 3; i++) {				
			b.add(100);
		}		
	}	
}

public class ThreadDemo1 {
	public static void main(String[] args) {
		
		Person p = new Person();//创建 Person类对象p
		Thread t = new Thread(p);//创建线程对象t
		Thread t2 = new Thread(p);//创建线程对象t2
		t.start();//启动t线程
		t2.start();
	}
}

从上面的例子可以看出同步的重要性，同步方法就别面了在处理多个线程共享同一个数据时，一个线程未完成处理某个方法时，另一个线程又闯了进来，这样就很好的提高了线程的安全性。