多线程-java程序设计课件

《多线程-java程序设计课件》由会员分享，可在线阅读，更多相关《多线程-java程序设计课件（55页珍藏版）》请在装配图网上搜索。

1、第8章 多线程 8.1 Java多线程概述 Java程序是运行在Java虚拟机（JVM）中的，在JVM的内部，程序的多任务是通过线程来实现的。用java命令运行一个java应用程序时，就会启动一个JVM进程。在这个JVM环境中，用户程序是以线程的形式来运行的。之前见到的Java应用程序都是单线程的，如用java命令运行一个最简单的HelloWorld的Java应用程序时，就启动了一个JVM进程，JVM找到程序程序的入口点main()，然后运行main()方法，这样就产生了一个线程，这个线程称之为主线程。8.2 线程的创建 8.2.1 直接继承Thread类创建线程 Java提供了类 java.

2、lang.Thread 来方便多线程编程，Thread 类称为线程类，这个类提供了大量的方法来方便我们控制线程。要创建一个线程，程序员可以创建一个从 Thread 类继承的新的线程类，新类必须覆盖从 Thread 类继承的 run()方法（称为线程体），加入线程所要执行的代码即可。新的线程类的对象就是线程对象，要启动线程，不能直接调用线程对象的run()方法，而是必须调用从父类Thread 类继承的 start()方法，该方法会自动调用run()方法来执行线程体。8.2.1 直接继承Thread类创建线程【实例实例8-1】直接继承Thread类创建线程class MyThread extend

3、s Thread/定义线程类int pauseTime;String name;public MyThread(int pauseTime,String name)this.pauseTime=pauseTime;this.name=name;Override/表示方法重写的Java注解public void run()/线程体int num=1;while(true)try System.out.println(name+:+num+);Thread.sleep(pauseTime);/线程休眠 pauseTime 毫秒 catch(Exception e)System.out.printl

4、n(e);8.2.1 直接继承Thread类创建线程 public class ThreadDemo/测试类public static void main(String args)MyThread tp1=new MyThread(1000,tp1);/创建线程tp1tp1.start();/启动线程tp1MyThread tp2=new MyThread(3000,tp2);/创建线程tp2tp2.start();/启动线程tp2 图8-1 一种运行结果8.2.2 通过实现 Runnable 接口创建线程 Runnable 是一个简单的接口，其中只有一个抽象方法run()，此方法必须由实现了

5、此接口的类给出具体实现。通过Runnable 接口创建线程的过程如下：（1）定义一个实现了 Runnable 接口的类，实现run()方法，在其中加入线程所要执行的代码。（2）创建该类的一个对象，然后再以该对象为参数创建Thread 类的一个对象，从而创建了一个线程对象。（3）最后调用该Thread 对象的start()方法来启动该线程。8.2.2 通过实现 Runnable 接口创建线程【实例实例8-2】通过实现 Runnable 接口创建线程class MyThread implements Runnable/定义一个实现了Runnable接口的类int pauseTime;String

6、name;public MyThread(int pauseTime,String name)this.pauseTime=pauseTime;this.name=name;Override/表示方法重写的Java注解public void run()/线程体int num=1;while(true)try System.out.println(name+:+num+);Thread.sleep(pauseTime);/线程休眠 pauseTime 毫秒 catch(Exception e)System.out.println(e);8.2.2 通过实现 Runnable 接口创建线程publ

7、ic class ThreadDemo2/测试类public static void main(String args)/创建线程tp1Thread tp1=new Thread(new MyThread(1000,tp1);tp1.start();/启动线程tp1/创建线程tp2Thread tp2=new Thread(new MyThread(3000,tp2);tp2.start();/启动线程tp28.2.3 两种创建线程方法的比较 方法方法1：直接继承：直接继承Thread类创建线程类创建线程缺点：Java 允许一个类有一个父类，所以线程类不能再从其它类继承。优点：编写简单，如果需

8、要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程对象。方法方法2：通过实现：通过实现 Runnable 接口创建线程接口创建线程缺点：编程稍复杂，如果需要访问当前线程，必须用Thread.currentThread()方法获取当前线程对象。优点：（1）可以避免由于Java的单继承特性带来的局限。（2）有利于程序的健壮性，代码能被多个线程共享，代码与数据是独立的。一般来说，对于简单的应用，可选择直接继承Thread类创建线程，对于相对复杂的应用，可以考虑使用通过实现 Runnable 接口创建线程。8.3 线程的状态 8.4 线程操作的

9、相关方法【实例实例8-3】取得线程名称 class MyThread implements Runnable/定义一个实现了Runnable接口的类 Override/表示方法重写的Java注解 public void run()/线程体System.out.println(线程的名字：+Thread.currentThread().getName();public class ThreadNameDemo/测试类 public static void main(String args)Thread tp1=new Thread(new MyThread();/创建线程tp1tp1.start

10、();/启动线程tp1Thread tp2=new Thread(new MyThread();/创建线程tp2tp2.start();/启动线程tp2 图8-3 运行结果8.4 线程操作的相关方法【实例实例8-4】线程休眠 class MyThread extends Thread Override/表示方法重写的Java注解public void run()/线程体for(int i=0;i 3;i+)try Thread.sleep(1000);/休眠1000毫秒 catch(InterruptedException e)e.printStackTrace();System.out.pr

11、intln(this.getName()+i=+i);8.4 线程操作的相关方法public class ThreadSleepDemo/测试类public static void main(String args)MyThread tp1=new MyThread();/创建线程tp1tp1.setName(tp1);/设置线程名字为tp1tp1.start();/启动线程tp1图8-4 运行结果8.4 线程操作的相关方法【实例实例8-5】线程暂时释放CPU，让给其它线程 class MyThread extends Thread Override/表示方法重写的Java注解public v

12、oid run()/线程体for(int i=0;i 4;i+)System.out.println(getName()+运行，i=+i);if(i=2)System.out.println(getName()+线程礼让!);Thread.yield();8.4 线程操作的相关方法public class ThreadYieldDemo/测试类public static void main(String args)MyThread tp1=new MyThread();/创建线程tp1tp1.setName(tp1);/设置线程名字为tp1tp1.start();/启动线程tp1MyThrea

13、d tp2=new MyThread();/创建线程tp1tp2.setName(tp2);/设置线程名字为tp1tp2.start();/启动线程tp1图8-5 运行结果8.4 线程操作的相关方法【实例实例8-6】线程的优先级 class MyThread extends Thread String name;MyThread(String name)this.name=name;Override/表示方法重写的Java注解public void run()/线程体for(int i=0;i 2;i+)System.out.println(name+getPriority();8.4 线程操

14、作的相关方法public class ThreadPriorityDemo/测试类public static void main(String args)MyThread t1=new MyThread(T1);t1.setPriority(Thread.MIN_PRIORITY);/设置最低优先级t1.start();MyThread t2=new MyThread(T2);t2.setPriority(Thread.MAX_PRIORITY);/设置最高优先级t2.start();MyThread t3=new MyThread(T3);t3.setPriority(Thread.MAX_

15、PRIORITY);/设置最高优先级t3.start();8.4 线程操作的相关方法图8-6 一次运行结果8.4 线程操作的相关方法【实例实例8-7】线程的join()方法使用class MyThread extends Thread String name;MyThread(String name)this.name=name;Override/表示方法重写的Java注解public void run()/线程体for(int i=0;i 0)/如果还有票int num=ticketNum;/num 是要售出的票号try Thread.sleep(200);/加入延时 catch(Inter

16、ruptedException e)ticketNum-;/要售出一张票，票数减1return num;/返回售出的票号return 0;/返回0表示无票了8.5.1 临界资源与多线程的互斥访问 class MyThread implements Runnable/售票线程类String name;Ticket ticket;MyThread(String name,Ticket ticket)this.name=name;this.ticket=ticket;Overridepublic void run()/线程体while(true)int i=ticket.sell();/i 是要售出

17、的票号if(i=0)break;/无票退出System.out.println(name+售出了:+i+号票);try Thread.sleep(200);/延时 catch(InterruptedException e)8.5.1 临界资源与多线程的互斥访问public class ThreadTicketDemo /测试类public static void main(String args)Ticket ticket=new Ticket();/创建票对象/*注意，创建下面两个线程时，使用同一个票对象ticket*/Thread tp1=new Thread(new MyThread(t

18、p1线程,ticket);Thread tp2=new Thread(new MyThread(tp2线程,ticket);tp1.start();/启动线程tp1tp2.start();/启动线程tp2图8-9 运行结果8.5.2 使用synchronized关键字解决互斥问题 解决共享资源的互斥访问，可以使用synchronized关键字。synchronized主要应用于同步代码块和同步方法中。同步代码块和同步方法一次只允许一个线程进入执行，从而保证了一个线程访问完了共享资源，另一个线程才能访问。同步代码块 public int sell()/售票方法synchronized(this)

19、/this是当前Ticket对象if(ticketNum 0)/如果还有票int num=ticketNum;/num 是要售出的票号try Thread.sleep(200);/加入延时 catch(InterruptedException e)ticketNum-;/要售出一张票，票数减1return num;/返回售出的票号return 0;/返回0表示无票了同步方法 public synchronized int sell()/售票方法if(ticketNum 0)/如果还有票int num=ticketNum;/num 是要售出的票号try Thread.sleep(200);/加入

20、延时 catch(InterruptedException e)ticketNum-;/要售出一张票，票数减1return num;/返回售出的票号return 0;/返回0表示无票了8.5.3 使用Lock解决互斥问题 java.utils.concurrent包是jdk1.5新增的，用来处理多线程互斥。实现java.util.concurrent.locks.Lock接口的类具有与synchronized关键字同样的功能，但是它更加强大一些。java.utils.concurrent.locks.ReentrantLock是较常用的实现了Lock接口的类。8.5.3 使用Lock解决互斥问

21、题class Ticket/票类private int ticketNum=3;/共有3张票，票号是1,2,3 private final Lock lock=new ReentrantLock();/锁对象public int sell()/售票方法lock.lock();/获取锁try if(ticketNum 0)/如果还有票int num=ticketNum;/num 是要售出的票号try Thread.sleep(200);/加入延时 catch(InterruptedException e)ticketNum-;/要售出一张票，票数减1return num;/返回售出的票号retu

22、rn 0;/返回0表示无票了 finally lock.unlock();/释放锁8.5.4 集合类对象的互斥访问 集合类是编程中经常要使用的，大多数的集合类都不是线程安全的（线程不同步），例如，经常用到的集合类ArrayList、LinkedList、HashSet和HashMap等都不是线程安全的。Java 5之后，新增了java.util.concurrent这个包，其中包括了一些确保线程安全的并发集合类，如CopyOnWriteArrayList、CopyOnWriteArraySet、CopyOnWriteArrayMap等类，根据具体的使用场合，开发者可以使用它们替代java.ut

23、il包中集合类，它们在效率与安全性上得到了较好的平衡。下面看一个CopyOnWriteArrayList的使用例子：private List list=new CopyOnWriteArrayList();.Iterator i=list.iterator();/无须放到synchronized 块中 while(i.hasNext()foo(i.next();8.5.5 多线程的同步 多线程之间有时需要协调工作，合作来完成任务，同步依赖于wait/notify/notifyAll()。wait()、notify()、notifyAll()不属于Thread类，而是属于Object类，也就是说

24、每个对象都有wait()、notify()、notifyAll()的功能。(1)wait,nofity,notifyAll必须在已经持有对象互斥锁的情况下使用，所以它们只能出现在synchronized作用的范围内。(2)wait的作用:使线程释放已持有的对象互斥锁,进入对象的wait队列，导致线程阻塞。(3)notify的作用:唤醒wait队列中的第一个线程并把它移入锁申请队列。(4)notifyAll的作用:唤醒wait队列中的所有的线程并把它们移入锁申请队列。8.5.5 多线程的同步【实例实例8-10】使用wait/notify解决生产者消费者同步问题class SyncStack/存储

25、产品（字符）的缓冲区，用栈实现private int index=0;/栈操作使用的数组下标private char buffer=new char6;/存储字符的数组public synchronized void push(char c)/压栈操作while(index=buffer.length)/如果栈满try this.wait();/线程阻塞 catch(InterruptedException e)bufferindex=c;/把字符c存储到数组中index+;this.notify();/唤醒栈对象wait队列中的第一个线程8.5.5 多线程的同步public synchron

26、ized char pop()/弹栈操作while(index=0)/如果栈空try this.wait();/线程阻塞 catch(InterruptedException e)this.notify();/唤醒栈对象wait队列中的第一个线程index-;return bufferindex;/返回栈顶元素8.5.5 多线程的同步class Producer implements Runnable/生产者SyncStack theStack;/使用的缓冲区public Producer(SyncStack s)theStack=s;Overridepublic void run()char

27、 c;for(int i=0;i 5;i+)c=(char)(Math.random()*26+A);/随机产生A-Z字符theStack.push(c);/把字符放到缓冲区System.out.println(Produced:+c);try Thread.sleep(int)(Math.random()*100);catch(InterruptedException e)8.5.5 多线程的同步class Consumer implements Runnable/消费者SyncStack theStack;/使用的缓冲区public Consumer(SyncStack s)theStac

28、k=s;Overridepublic void run()char c;for(int i=0;i 5;i+)c=theStack.pop();/从缓冲区取字符System.out.println(Consumed:+c);try Thread.sleep(int)(Math.random()*200);catch(InterruptedException e)8.5.5 多线程的同步public class ProducerConsumerDemo/测试类public static void main(String args)SyncStack stack=new SyncStack();/

29、创建缓冲区Thread t1=new Thread(new Producer(stack);Thread t2=new Thread(new Consumer(stack);t1.start();/启动生产者线程t2.start();/启动消费者线程图8-10 运行结果8.6 应用实例Web服务器模拟 一、问题描述一、问题描述对于一个web应用程序，每当一个客户浏览器请求服务时，服务器就启动一个新的服务器线程为客户服务。因为创建和销毁线程会有一定的开销，所以，一般都会使用线程池，服务器启动时就创建一些服务器线程，把它们放到线程池中，有客户请求，就从线程池取出一个空闲的线程为客户服务，服务完毕，

30、服务器线程并不结束，会继续在线程池中等待。这样就避免了频繁地创建和销毁线程了。在这里，模拟web应用程序中客户浏览器和服务器线程的交互。8.6 应用实例Web服务器模拟二、算法和实现二、算法和实现客户浏览器有多种，所以，定义一个客户浏览器请求接口，在其中定义一个抽象方法request()，代表客户浏览器请求。再为它提供两个实现类，一个是IE浏览器请求类，另一个是火狐浏览器请求类。定义一个存放浏览器请求对象的队列类，定义一个服务器线程类，服务器线程可以从浏览器请求对象队列取出浏览器请求对象为它服务（这里只是调用一下浏览器请求对象的request()方法，表示为它服务）。再定义一个服务器线程池类，

31、提供把服务器线程添加其中、从池中删除、输出线程池中服务器线程的状态3个方法。8.6 应用实例Web服务器模拟import java.util.Iterator;import java.util.LinkedList;import java.util.List;interface Client/客户浏览器请求接口void request();/浏览器请求方法class IEClient implements Client/IE浏览器请求private static int count=0;/浏览器对象数private int num=count;/当前浏览器序号public IEClient()

32、count+;8.6 应用实例Web服务器模拟Overridepublic void request()try Thread.sleep(500);catch(InterruptedException e)System.out.println(IEClient+num+被服务了！);8.6 应用实例Web服务器模拟class FireFoxClient implements Client/火狐浏览器请求private static int count=0;/浏览器对象数private int num=count;/当前浏览器序号public FireFoxClient()count+;Over

33、ridepublic void request()try Thread.sleep(500);catch(InterruptedException e)System.out.println(FireFoxClient+num+被服务了！);8.6 应用实例Web服务器模拟class ClientQueue/存放浏览器对象的队列类private List queue=new LinkedList();/*从队列中取出浏览器对象*/public synchronized Client getClient()while(queue.size()=0)try this.wait();/线程阻塞 cat

34、ch(InterruptedException e)return null;return queue.remove(0);8.6 应用实例Web服务器模拟/*将浏览器对象放入队列中*/public synchronized void putClient(Client client)queue.add(client);this.notifyAll();class ServerThread extends Thread/服务器线程类private static int count=0;/服务器线程对象数private boolean isBusy=false;/当前服务器线程是否忙private

35、boolean isStop=false;/当前服务器线程是否结束private ClientQueue queue;/存放浏览器对象的队列对象8.6 应用实例Web服务器模拟public ServerThread(ClientQueue queue)super(Server-+count);/参数是线程名count+;this.queue=queue;public void shutdown()/安全结束线程方法isStop=true;this.interrupt();/中断当前线程try this.join();/等待线程结束 catch(InterruptedException e)8.

36、6 应用实例Web服务器模拟public boolean isIdle()/判断线程是否空闲return!isBusy;Overridepublic void run()System.out.println(this.getName()+启动了！);while(!isStop)/用isStop来控制线程结束Client client=queue.getClient();/取出浏览器对象if(client!=null)isBusy=true;client.request();/为浏览器对象服务isBusy=false;System.out.println(this.getName()+结束了！)

37、;8.6 应用实例Web服务器模拟class ServerThreadPool/服务器线程池类private List threadsList=new LinkedList();private ClientQueue queue;/存放浏览器对象的队列对象public ServerThreadPool(ClientQueue queue)this.queue=queue;/*把一个服务器线程添加到线程池*/public synchronized void addServerThread()ServerThread t=new ServerThread(queue);threadsList.ad

38、d(t);t.start();8.6 应用实例Web服务器模拟/*从线程池删除一个服务器线程*/public synchronized void removeServerThread()if(threadsList.size()0)ServerThread t=threadsList.remove(0);t.shutdown();/安全结束服务器线程8.6 应用实例Web服务器模拟/*输出线程池中线程状态*/public synchronized void currentStatus()System.out.println(-);System.out.println(当前线程个数：+threa

39、dsList.size();Iterator it=threadsList.iterator();while(it.hasNext()ServerThread t=it.next();System.out.println(t.getName()+:+(t.isIdle()?空闲:繁忙);System.out.println(-);8.6 应用实例Web服务器模拟public class ThreadApp/测试类public static void main(String args)ClientQueue queue=new ClientQueue();/存放浏览器对象的队列对象 Server

40、ThreadPool pool=new ServerThreadPool(queue);/服务器线程池对象 for(int i=0;i3;i+)queue.putClient(new IEClient();/向队列添加IE浏览器对象queue.putClient(new FireFoxClient();/向队列添加火狐浏览器对象 pool.addServerThread();/向线程池添加一个服务器线程对象 pool.addServerThread();8.6 应用实例Web服务器模拟doSleep(1000);/主线程休眠1秒pool.currentStatus();/输出线程池中线程状态doSleep(3000);/主线程休眠3秒pool.removeServerThread();/从线程池删除一个服务器线程pool.removeServerThread();pool.currentStatus();/再次输出线程池中线程状态private static void doSleep(long ms)/休眠方法try Thread.sleep(ms);catch(InterruptedException e)8.6 应用实例Web服务器模拟图8-11 运行结果