Java是第一个在语言级提供了对多线程程序设计支持的语言。语言级支持是啥意思呢,就是抛开操作系统,只使用Java内置的语句就能实现多线程。一般来讲,多线程会依赖操作系统,我们要高用与系统相关的API才能创建多个线程,如在Windows中的CreateThread()函数。但JAVA就不用了。JAVA运行时系统实现了一个用于调用线程执行的线程调度器,用来决定在某一时刻哪个线程在CPU上运行。
在java技术中,线程通常是抢占式的而不需要时间片分配进程(分配给每个线程相等的CPU时间的进程)。抢占式调度模型就是许多线程处于可以运行状态(等待状态),但实际上只有一个线程在运行。该线程一直运行到它终止进入可运行状态(等待状态),或者另一个具有更高优先级的线程变成可运行状态。在后一种情况下,低优先级的线程被高优先级的线程抢占,高优先级的线程获得运行的机会。线程调度器支持不同优先级线程的抢先方式,但其本身不支持相同优先级线程的时间片轮换。若要想让其支持,则必须将运行时系统运行在支持时间片轮换操作系统上。
1、Thread类和Runnable接口
在Java中实现多线程可以有2种方式,一个是让类继承Thread类,另一个是实现Runnable接口。由于Java不允许多继承,所以当我们让自定义的类继承了Thread类后就不能再继承其它类了,这样会降低日后程序的可扩展性。所以一般我们都是采用实现Runnable接口的方法让一个类具有可执行的特性。
Runnable接口只有一个方法run(),该线程启动时,JVM就会调用run()方法以执行该线程。线程类创建后,必须调用start()方法才能启动线程。如:
- package cls;
- public class ThreadDemo
- {
- public static void main(String[] args)
- {
- //创建线程类对象并实现 Runnable接口
- Thread th1 = new Thread(new Runnable()
- {
- // 实现Runnable中的run()方法
- public void run()
- {
- while(true)
- System.out.println("Thread1 is running !");
- }
- });
- Thread th2 = new Thread(new Runnable()
- {
- public void run()
- {
- while(true)
- System.out.println("Thread2 is running !");
- }
- });
- // 调用start()方法启动线程
- th1.start();
- th2.start();
- }
- }
2、Daemon线程
一个Daemon线程指的是一个在后台执行服务的线程。在执行上例代码时,我们发现,当主线程(main函数)执行完th2.start()这一行的时候,主线程的代码就已经全部执行完,所以主线程退出了。但我们看到自己创建的th1和th2两个线程仍然在不停地执行,并没有退出。如果我们想让创建的线程在主函数退出后一同退出,那么就应当将我们创建的线程设置为daemon.Daemon线程当在所有的非Daemon线程都结束后自动退出。
让我们修改一下上例:
- package cls;
- public class ThreadDemo
- {
- public static void main(String[] args)
- {
- //创建线程类对象并实现 Runnable接口
- Thread th1 = new Thread(new Runnable()
- {
- // 实现Runnable中的run()方法
- public void run()
- {
- while(true)
- System.out.println("Thread1 is running !");
- }
- });
- Thread th2 = new Thread(new Runnable()
- {
- public void run()
- {
- while(true)
- System.out.println("Thread2 is running !");
- }
- });
- // 设置成daemon线程
- th1.setDaemon(true);
- th2.setDaemon(true);
- // 调用start()方法启动线程
- th1.start();
- th2.start();
- // 主函数睡眠一小会
- try
- {
- Thread.currentThread().sleep(200);
- }
- catch(Exception e)
- {
- System.out.println(e.toString());
- }
- }
- }
3、线程同步
假设对象A有两个属性a和b,另有一个对象B有属性a和b,并且我们要用对象B来更新对象A。当这种更新操作完成后(对象A的a,b属性值变成了对象B的a,b属性值),则称A与B同步。
如果对象B在更新对象A时(还没更新完),又来了个对象C,对象C抢在B之前更新了A,则称A与B不同步。
讨论线程就不得不考虑线程同步的问题。当多个线程共享同一个数据时,容易造成数据的不同步。而这种不同步引发的错误往往难以修正,常常是程序在执行了几千次、几万次甚至是几年才会出现。因此线程同步就显得尤为重要。
下面写一个模拟火车站卖票的例子,故意使得线程不同步,看看会发生什么问题:
- package cls;
- public class ThreadSynchronized
- {
- public static void main(String[] args)
- {
- Ticket tk = new Ticket();
- Thread th1 = new Thread(new Sold(tk));
- Thread th2 = new Thread(new Sold(tk));
- th1.start();
- th2.start();
- }
- }
- class Ticket
- {
- int amount = 100; // 有100张票
- // 卖出一张票,总票数减1,返回被卖出的票号
- public int sold()
- {
- return amount--;
- }
- // 返回当前剩余票数
- public int getAmount()
- {
- return amount;
- }
- }
- // 售票线程
- class Sold implements Runnable
- {
- private Ticket tk;
- public Sold1(Ticket tk)
- {
- this.tk = tk;
- }
- public void run()
- {
- while(tk.getAmount() > 0) // 还有余票
- {
- try
- {
- Thread.currentThread().sleep(10); // 睡眠一小会
- }
- catch(Exception e)
- {
- System.out.println(e.toString());
- }
- System.out.println("Thread1 sold " + tk.sold());
- }
- }
- }
执行:
我们发现,Thread1这个线程居然卖出了0这张不存在的票。售票线程在卖票前已经做了
- tk.getAmount() > 0
我们来分析下程序执行的过程:
当还剩下1这张票时,Thread1用getAmout()判断出票数大于0,则进入while循环进行售票。在还没有卖之前遇到了sleep(),于是Thread1会放弃执行机会,进入阻塞状态;这时轮到Thread2执行了,由于Thead1还没有把1卖出,因此Thread2用getAmout()的结果仍然大于0,所以就把1这张票卖出去了。这时候Thread1睡醒了,则继续从sleep()这行开始执行,而这时候票数已经变成了0,那么Thead1自然就会卖出0这张票了。
为了避免此类情况的发生,我们可以使用synchronized关键字来进行线程的同步。
synchronized关键字可以用在方法上,也可以用在语句块中。我们可以形象地把synchronized想象成一把锁。当程序执行到synchronized语句块(以后称为同步块)时,会将这个同步块的代码“上锁”,这时如果我们调用了sleep()方法或者恰好CPU分配的时间片用光了,另一个线程如果也要执行这段代码时,由于先前的线程已经对这个同步块进行了“上锁”,因此这个线程就不能执行同步块中的代码,只能等待,直到它的时间片也用完为止。这时前一个线程又得到了执行的机会,执行完代码块,它会将这个代码块“解锁”,这样别的线程才可以执行这个代码块。也就是说,一个同步块在一个时间段内只能被一个特定的线程执行,在这个线程没有执行完代码块的语句之前,其它线程是没有办法再执行这个块中的代码的。Java是通过请求一个对象的监视器实现这种功能的。一个对象只有一个监视器,当一个线程请求到后,另一个线程在这个线程归还(执行完同步块)监视器之前是无法请求到该对象的监视器的。
现在我们来改写上面的例子:
- package cls;
- class ThreadSynchronized
- {
- public static void main(String[] args)
- {
- Ticket tk = new Ticket();
- Sold sd = new Sold(tk);
- Thread th1 = new Thread(sd);
- Thread th2 = new Thread(sd);
- th1.start();
- th2.start();
- }
- }
- class Ticket
- {
- int amount = 100; // 有100张票
- // 卖出一张票,总票数减1,返回被卖出的票号
- public int sold()
- {
- return amount--;
- }
- // 返回当前剩余票数
- public int getAmount()
- {
- return amount;
- }
- }
- // 售票线程
- class Sold implements Runnable
- {
- private Ticket tk;
- public Sold(Ticket tk)
- {
- this.tk = tk;
- }
- public void run()
- {
- while(true)
- {
- // 同步语句块
- synchronized(this)//请求 this对象的监视器
- {
- if(tk.getAmount() > 0)
- {
- try
- {
- Thread.currentThread().sleep(1); // 睡眠一小会
- }
- catch(Exception e)
- {
- System.out.println(e.toString());
- }
- System.out.println(Thread.currentThread().getName() + " sold " + tk.sold());
- }
- }
- }
- }
- }
可以看到,问题就解决了。
原文地址:点击打开链接