黑马程序员--多线程

-------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IO开发S</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

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

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

线程的生命周期：新生状态、就绪状态、运行状态、阻塞状态、死亡状态。

多线程的实现方式：第一种方法是通过创建Thread类的的子类来实现，另一种方法是通过实现Runable接口的类来实现。

如何通过创建Thread类的的子类来实现多线程呢？步骤如下

（1）定义类继承Thread

（2）复写Thread类中的run方法（将自定义代码存在run方法中，让线程运行）。

（3）调用线程的start方法。（该方法有两个作用：启动线程和调用run方法）

为什么要复写Thread类中的run方法呢？

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

为什么不是调用run方法来启动线程呢？

因为run()仅仅是对象的调用方法，而线程创建了并没有运行。

线程都有自己默认的名称，是Thread-编号（编号从0开始）。

线程中几个常用的方法：

（1）getName();获取线程的名称。

（2）static Thread  currentThread();返回对当前正在执行的线程对象的引用。

例子：用第一种方式创建一个线程。实现多个窗口同时售票

class Ticket extends Thread 
{
	private static int tick = 100;
	Ticket(String name)
	{
		super(name);
	}
	public void run()
	{
		while(true)
		{
			if(tick>0)
			{
				System.out.println(this.getName()+"....sale:"+ tick--);
			}
		}
	}
}

class TicketDemo
{
	public static void main(String[] args) 
	{
		Ticket t1 = new Ticket("window 1");
		Ticket t2 = new Ticket("window 2");
		Ticket t3 = new Ticket("window 3");

		t1.start();
		t2.start();
		t3.start();
	}
}

如何通过实现Runnable接口的类的方法来创建线程呢？过程如下

（1）定义类实现Runnable接口

（2）覆盖Runnable接口中的run方法

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

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

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

为什么要将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数呢？

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

例子：用实现Runnable接口的方法创建线程

/*售票
实现多个窗口同时售票
*/
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,"window 1");
		Thread t2 = new Thread(t,"window 2");
		Thread t3 = new Thread(t,"window 3");

		t1.start();
		t2.start();
		t3.start();
	}
}

两种创建线程方式的区别：

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

实现Runnable接口的方法，线程代码存放在接口子类的run方法中。该方法还避免了单继承的局限性。

在定义线程时，建议使用实现Runnable接口的方法。

对多线程运行出现了安全问题进行分析和解决：

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

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

synchronized(对象)

{

需要被同步的代码

}

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

同步前提：

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

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

例子：安全问题解决后的售票例子

/*售票
实现多个窗口同时售票
*/
class Ticket implements Runnable 
{
	private  int tick = 100;
	Object obj = new Object();
	public void run()
	{
		while(true)
		{
			synchronized(obj)
			{
				if(tick>0)
				{
					try
					{
						Thread.sleep(10);
					}
					catch (Exception e)
					{
						throw new RuntimeException("线程休眠失败");
					}
					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,"window 1");
		Thread t2 = new Thread(t,"window 2");
		Thread t3 = new Thread(t,"window 3");

		t1.start();
		t2.start();
		t3.start();
	}
}

同步函数一般使用的锁（对象）都是this，但是如果同步函数被static修饰后，使用的锁就是类名.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;
	}
}

------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

转载于:https://www.cnblogs.com/java20130722/p/3207038.html