创建线程有两种方式:第一种是继承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对象来新建多个线程对象。这就保证了票的唯一性,锁的唯一性也保证了。