多线程 创建线程的两种方式

创建线程有两种方式：第一种是继承Thread类，第二种是实现Runnable接口。下面详细介绍两种线程创建的方式，这个内容为必须掌握的。到最后会对比两种方式创建线程的优势和劣势。

1继承Thread类创建线程：

1，创建一个类，继承Thread类并覆盖Thread类的run方法。为什么要覆盖run方法？该run方法的方法体就是代表了线程要完成的任务，因此，run方法也称为线程执行体。

2，创建Thread子类的实例，即创建了线程对象。

3，用线程对象调用start方法启动线程。

下面来看看代码是如何实现的：

public class ThreadCreat
{
	public static void main(String args[]){
		MyThread mt = new MyThread(); //创建Thread子类实例对象
		mt.start(); //通过子类对象的start方法开启线程
		for(int x=0;x<10;x++)
			System.out.println(Thread.currentThread().getName()+"-->"+x);
		
	} 
}
class MyThread extends Thread  //新建一个类继承Thread
{
	public void run(){  //覆盖run方法，方体即线程体
		for(int i=0;i<10;i++)
			System.out.println(this.getName()+"--->"+i);
	}
}

---------- 运行java程序 ----------

main-->0

main-->1

Thread-0--->0

Thread-0--->1

main-->2

main-->3

main-->4

main-->5

main-->6

main-->7

main-->8

main-->9

Thread-0--->2

Thread-0--->3

Thread-0--->4

Thread-0--->5

Thread-0--->6

Thread-0--->7

Thread-0--->8

Thread-0--->9

输出完成 (耗时 0 秒) - 正常终止

在打印时，我使用了Thread类中静态方法currentThread ，调用该方法可以返回当前正在执行的线程对象（Thread）。从输出可以看到，在本程序中，开启了两条线程，一条是主线程：

main，另外一条是Thread-0线程。这两条线程是随机交替进行的。对于单核cpu在某一个时间点上只能执行一个命名，由于cpu切换的非常快，人是无法察觉它的切换，给人的感觉实在同时执行多个任务。知道了这一点，有利于我们理解多线程。

下面再来看看为何会出现上面的输出结果：

2线程创建的第二种方式：实现Runnable接口

1，创建一个类实现Runnable接口，并覆盖run方法，run方法体就是线程体。

2，新建一个Thread本类对象，在新建该对象时，使用的是其Thread(Runnable  target)构造方法，将Runnable 子类对象作为参数传递给该构造方法。

3，调用Thread的start方法，启动线程。

下面看看代码是如何实现的：

public class ThreadCreat2
{
	public static void main(String args[]){
		new Thread(new MyThread2()).start();//将实现了Runnable接口的类的实例对象作为                                         //参数传递给Thread类的实例对象
		for(int i=0;i<10;i++)
			System.out.println(Thread.currentThread().getName()+"-->"+i);
	}
}
class MyThread2 implements Runnable //实现Runnable接口
{
	public void run(){
		for(int i=0;i<10;i++)
			System.out.println(Thread.currentThread().getName()+"-->"+i);
	}
}

---------- 运行java程序 ----------

main-->0

main-->1

main-->2

main-->3

main-->4

main-->5

main-->6

Thread-0-->0

Thread-0-->1

main-->7

main-->8

main-->9

Thread-0-->2

Thread-0-->3

Thread-0-->4

Thread-0-->5

Thread-0-->6

Thread-0-->7

Thread-0-->8

Thread-0-->9

输出完成 (耗时 0 秒) - 正常终止

从运行结果也可以看到，主线程（main）和Thread-0线程时随机交替执行的。

看完两种创建线程的方式后，我们来对比下两种线程的优势和劣势：

采用继承Thread类方式完成多线程建立：

劣势是：因为线程类已经继承了Thread类，所以不能再继承其他父类。

优势是：编写简单，如果需要访问线程，无需使用Thread.currentThread()方法，直接

使用this即可获得当前线程。

采用实现Runnable接口方式的多线程：

优势是：线程类只是实现了Runnable接口，还可以继承其他类。在这种方式下，可以多个线程共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，较好的体现了面向对象的思想。

劣势是：编程稍稍复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

推荐使用实现Runnable接口的方式创建线程对象。

3，售票程序

现在用多线程来模拟一个实际情况：

现在有四个售票厅，同时在卖100张票，这100张票是他们共有的，售完即停。

我们先来看下代码是如何实现的：

public class SoldTickets
{
	public static void main(String args[]){
		Tickets t1 = new Tickets();
		Tickets t2 = new Tickets();
		Tickets t3 = new Tickets();
		Tickets t4 = new Tickets();//新建四个线程对象

		t1.start(); //开启四个卖票线程
		t2.start();
	    t3.start();
		t4.start();
	}
}
class Tickets extends Thread
{
	public static int ticket = 100;  //这里加静态时为了保证卖的票是100张
    static Object obj = new Object();  //要保证锁的唯一性，就需要用static关键字修饰
	public void run(){
		while(true){
			synchronized(obj){  //线程使用的是同一个锁
					if(ticket>0){
					System.out.println(this.getName()+"-->"+ticket);
					ticket--;
				}
			}
		}
	}
}

上面是通过继承Thread类来完成卖票程序的。重点是要保证多个线程处理的是同一份数据，其二，关键代码要用同步代码块。在以上代码中是如何实现的了？

我们来看高亮的注释：

由于是继承Thread类，要开启多条线程，就会新建多个对象，为了保证卖的票是唯一的

public static int ticket = 100; 不管我们新建多少对象，用static关键字修饰的成员变量，在内存中只有一份。至于另一个问题，同步代码块和锁的问题会留在下一节会详细讲解，并给出为何要同步的原因。

再来看看实现Runnable接口的类是如何完成卖票程序的： 

public class SoldTickets2
{
	public static void main(String args[]){
		TicketsDemo td = new TicketsDemo();
		Thread t1 = new Thread(td);
		Thread t2 = new Thread(td);
		Thread t3 = new Thread(td);
		Thread t4 = new Thread(td);

		t1.start();
	    t2.start();
		t3.start();
		t4.start();
	}
}
class TicketsDemo implements Runnable
{
	public int tickets = 100;   //注意这里并没有加static
	Object obj = new Object(); //这里也没有加static
	public void run(){
		while(true){
			synchronized(obj){  //加锁
				if(tickets>0){
					System.out.println(Thread.currentThread().getName()+"-->"+tickets);
					tickets--;
				}
			}
		}
	}
}

我们来看看，这段代码是如何保证卖的是共同的100张票。

由于我们是采用的是实现Runnable接口方式来创建线程的。我们只需要新建一个TicketsDemo类实例对象；在创建线程对象时通过新建Thread本类对象来完成的，同时将TicketsDemo作为参数传递给Thread的有参构造器，完成线程的建立。这样一来，我们可以用同一个TicketsDemo对象来新建多个线程对象。这就保证了票的唯一性，锁的唯一性也保证了。