精华内容
下载资源
问答
  • java多线程编程

    2018-10-27 08:07:23
    java多线程编程
  • java 多线程编程

    2010-06-23 15:41:24
    java多线程编程java多线程编程java多线程编程
  • JAVA多线程编程

    2012-03-12 23:25:43
    JAVA多线程编程主要将java线程,从原理开始讲起
  • Java多线程编程

    万次阅读 2016-06-17 22:08:38
    Java多线程编程 Java给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称作一 个线程,并且每个线程定义了一个独立的执行路径。 多线程是多任务的一种特别...

    Java多线程编程


    Java给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称作一

    个线程,并且每个线程定义了一个独立的执行路径。


    多线程是多任务的一种特别的形式。多线程比多任务需要更小的开销。


    这里定义和线程相关的另一个术语:进程:一个进程包括由操作系统分配的内存空间,包含一个或多个线程。一个线

    程不能独立的存在,它必须是进程的一部分。一个进程一直运行,直到所有的非守候线程都结束运行后才能结束。


    多线程能满足程序员编写非常有效率的程序来达到充分利用CPU的目的,因为CPU的空闲时间能够保持在最低限度。


    一个线程的生命周


    线程经过其生命周期的各个阶段。下图显示了一个线程完整的生命周期。



    新状态: 一个新产生的线程从新状态开始了它的生命周期。它保持这个状态知道程序start这个线程。


    运行状态:当一个新状态的线程被start以后,线程就变成可运行状态,一个线程在此状态下被认为是开始执行其任务


    就绪状态:当一个线程等待另外一个线程执行一个任务的时候,该线程就进入就绪状态。当另一个线程给就绪状态的

    线程发送信号时,该线程才重新切换到运行状态。


    休眠状态: 由于一个线程的时间片用完了,该线程从运行状态进入休眠状态。当时间间隔到期或者等待的时间发生

    了,该状态的线程切换到运行状态。


    终止状态: 一个运行状态的线程完成任务或者其他终止条件发生,该线程就切换到终止状态。


    线程的优先级


    每一个Java线程都有一个优先级,这样有助于操作系统确定线程的调度顺序。Java优先级在MIN_PRIORITY(1)和

    MAX_PRIORITY(10)之间的范围内。默认情况下,每一个线程都会分配一个优先级NORM_PRIORITY(5)。


    具有较高优先级的线程对程序更重要,并且应该在低优先级的线程之前分配处理器时间。然而,线程优先级不能保证

    线程执行的顺序,而且非常依赖于平台。


    创建一个线程


    Java提供了两种创建线程方法:


    通过实现Runable接口;


    通过继承Thread类本身。


    通过实现Runnable接口来创建线程


    创建一个线程,最简单的方法是创建一个实现Runnable接口的类。


    为了实现Runnable接口,一个类只需要执行一个方法调用run(),声明如下:

    <span style="font-size:18px;">public void run()</span>

    你可以重写该方法,重要的是理解的run()可以调用其他方法,使用其他类,并声明变量,就像主线程一样。


    在创建一个实现Runnable接口的类之后,你可以在类中实例化一个线程对象。


    Thread类中定义了几个构造方法,下面的这个是我们经常使用的:

    <span style="font-size:18px;">Thread(Runnable threadOb,String threadName);</span>

    这里,threadOb 是一个实现Runnable 接口的类的实例,并且 threadName指定新线程的名字。


    新线程创建之后,你调用它的start()方法它才会运行。

    <span style="font-size:18px;">void start();</span>


    实例


    下面是一个创建线程并开始让它执行的实例:

    <span style="font-size:18px;">//创建一个新的线程
    class NewThread implements Runnable {
       Thread t;
       NewThread() {
          //创建第二个新线程
          t = new Thread(this, "Demo Thread");
          System.out.println("Child thread: " + t);
          // 开始线程
          t.start(); 
       }
    
       //第二个线程入口
       public void run() {
          try {
             for(int i = 5; i > 0; i--) {
                System.out.println("Child Thread: " + i);
                // 暂停线程
                Thread.sleep(50);
             }
         } catch (InterruptedException e) {
             System.out.println("Child interrupted.");
         }
         System.out.println("Exiting child thread.");
       }
    }
    
    public class ThreadDemo {
       public static void main(String args[]) {
          //创建一个新线程
          new NewThread(); 
          try {
             for(int i = 5; i > 0; i--) {
               System.out.println("Main Thread: " + i);
               Thread.sleep(100);
             }
          } catch (InterruptedException e) {
             System.out.println("Main thread interrupted.");
          }
          System.out.println("Main thread exiting.");
       }
    }</span>

    编译以上程序运行结果如下:



    通过继承Thread类来创建线程


    创建一个线程的第二种方法是创建一个新的类,该类继承Thread类,然后创建一个该类的实例。


    继承类必须重写run()方法,该方法是新线程的入口点。它也必须调用start()方法才能执行。


    实例


    下面是一个创建线程并开始让它执行的实例:

    <span style="font-size:18px;">// 通过继承Thread类创建线程
    class NewThread extends Thread {
       NewThread() {
          //创建第二个新线程
          super("Demo Thread");
          System.out.println("Child thread: " + this);
    	  //开始线程
          start(); 
       }
      
       //第二个线程入口
       public void run() {
          try {
             for(int i = 5; i > 0; i--) {
                System.out.println("Child Thread: " + i);
                //让线程休眠一会
                Thread.sleep(50);
             }
          } catch (InterruptedException e) {
             System.out.println("Child interrupted.");
          }
          System.out.println("Exiting child thread.");
       }
    }
      
    public class ExtendsThread {
       public static void main(String args[]) {
    	  //创建一个新线程
          new NewThread(); 
          try {
             for(int i = 5; i > 0; i--) {
                System.out.println("Main Thread: " + i);
                Thread.sleep(100);
             }
          } catch (InterruptedException e) {
             System.out.println("Main thread interrupted.");
          }
          System.out.println("Main thread exiting.");
       }
    }</span>

    编译以上程序运行结果如下:


    Thread类方法


    下表列出了Thread类的一些重要方法:



    测试线程是否处于活动状态。 上述方法是被Thread对象调用的。下面的方法是Thread类的静态方法。



    实例


    如下的ThreadClassDemo程序演示了Thread类的一些方法:

    文件名: DisplayMessage.java

    <span style="font-size:18px;">//通过实现Runnable接口创建线程
    public class DisplayMessage implements Runnable{
       private String message;
       
       public DisplayMessage(String message){
          this.message = message;
       }
       
       public void run(){
          while(true){
             System.out.println(message);
          }
       }
    }</span>

    文件名: GuessANumber.java

    <span style="font-size:18px;">//通过继承Thread类创建线程
    public class GuessANumber extends Thread{
       private int number;
       
       //构造方法
       public GuessANumber(int number){
          this.number = number;
       }
       
       public void run(){
          int counter = 0;
          int guess = 0;
    	  
          do{
              guess = (int) (Math.random() * 100 + 1);
              System.out.println(this.getName()
                           + " guesses " + guess);
              counter++;
          }while(guess != number);
    	  
          System.out.println("** Correct! " + this.getName()+ " in " + counter + " guesses.**");
       }
    }</span>

    文件名: ThreadClassDemo.java

    <span style="font-size:18px;">//测试类ThreadClassDemo
    public class ThreadClassDemo{
       public static void main(String [] args){
          Runnable hello = new DisplayMessage("Hello");
          Thread thread1 = new Thread(hello);
          thread1.setDaemon(true);
          thread1.setName("hello");
          System.out.println("Starting hello thread...");
          thread1.start();
          
          Runnable bye = new DisplayMessage("Goodbye");
          Thread thread2 = new Thread(bye);
          thread2.setPriority(Thread.MIN_PRIORITY);
          thread2.setDaemon(true);
          System.out.println("Starting goodbye thread...");
          thread2.start();
      
          System.out.println("Starting thread3...");
          Thread thread3 = new GuessANumber(27);
          thread3.start();
          try{
             thread3.join();
          }catch(InterruptedException e){
             System.out.println("Thread interrupted.");
          }
          System.out.println("Starting thread4...");
          Thread thread4 = new GuessANumber(75);
          
          thread4.start();
          System.out.println("main() is ending...");
       }
    }</span>

    运行结果如下,每一次运行的结果都不一样。


    线程的几个主要概念:


    在多线程编程时,你需要了解以下几个概念:


    线程同步


    线程间通信


    线程死锁


    线程控制:挂起、停止和恢复


    多线程的使用


    有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如:程序中有两个子系统需要并发执行,这时候

    就需要利用多线程编程。


    通过对多线程的使用,可以编写出非常高效的程序。不过请注意,如果你创建太多的线程,程序执行的效率实际上是

    降低了,而不是提升了。


    请记住,上下文的切换开销也很重要,如果你创建了太多的线程,CPU花费在上下文的切换的时间将多于执行程序的

    时间!



    展开全文
  • java多线程编程实例

    万次阅读 多人点赞 2018-05-25 10:01:22
    这篇文章主要介绍了java多线程编程实例,分享了几则多线程的实例代码,具有一定参考价值,加深多线程编程的理解还是很有帮助的,需要的朋友可以参考下。1.相关知识:Java多线程程序设计到的知识:(1)对同一个数量...

            这篇文章主要介绍了java多线程编程实例,分享了几则多线程的实例代码,具有一定参考价值,加深多线程编程的理解还是很有帮助的,需要的朋友可以参考下。

    1.三个售票窗口同时出售20张票

    程序分析:
        (1)票数要使用同一个静态值
        (2)为保证不会出现卖出同一个票数,要java多线程同步锁。
    设计思路:
        (1)创建一个站台类Station,继承Thread,重写run方法,在run方法里面执行售票操作!售票要使用同步锁:即有一个站台卖这张票时,其他站台要等这张票卖完!
        (2)创建主方法调用类

    (一)创建一个站台类,继承Thread

    package com.xykj.threadStation;
    public class Station extends Thread {
        // 通过构造方法给线程名字赋值
        public Station(String name) {
           super(name);// 给线程名字赋值
        }
        // 为了保持票数的一致,票数要静态
        static int tick = 20;
        // 创建一个静态钥匙
        static Object ob = "aa";//值是任意的
        // 重写run方法,实现买票操作
        @Override
        public void run() {
          while (tick > 0) {
            synchronized (ob) {// 这个很重要,必须使用一个锁,
              // 进去的人会把钥匙拿在手上,出来后才把钥匙拿让出来
              if (tick > 0) {
                System.out.println(getName() + "卖出了第" + tick + "张票");
                tick--;
              } else {
                System.out.println("票卖完了");
              }
            }
            try {
               sleep(1000);//休息一秒
            } catch (InterruptedException e) {
              e.printStackTrace();
            }
          }
      }
    }

    (二)创建主方法调用类

    package com.xykj.threadStation;
    public class MainClass {
      /**
       * java多线程同步锁的使用
       * 示例:三个售票窗口同时出售10张票
       * */
      public static void main(String[] args) {
        //实例化站台对象,并为每一个站台取名字
         Station station1=new Station("窗口1");
         Station station2=new Station("窗口2");
         Station station3=new Station("窗口3");
        // 让每一个站台对象各自开始工作
         station1.start();
         station2.start();
         station3.start();
      }
    }

    程序运行结果:

    窗口1卖出了第20张票
    窗口2卖出了第19张票
    窗口3卖出了第18张票
    窗口3卖出了第17张票
    窗口1卖出了第16张票
    窗口2卖出了第15张票
    窗口3卖出了第14张票
    窗口1卖出了第13张票
    窗口2卖出了第12张票
    窗口2卖出了第11张票
    窗口1卖出了第10张票
    窗口3卖出了第9张票
    窗口3卖出了第8张票
    窗口1卖出了第7张票
    窗口2卖出了第6张票
    窗口3卖出了第5张票
    窗口1卖出了第4张票
    窗口2卖出了第3张票
    窗口3卖出了第2张票
    窗口1卖出了第1张票
    票卖完了

    可以看到票数是不会有错的!

    2.两个人AB通过一个账户A在柜台取钱和B在ATM机取钱!

    程序分析:
            钱的数量要设置成一个静态的变量,两个人要取的同一个对象值。
    (一)创建一个Bank类
    package com.thread.demo.demo2;
    
    import java.util.Objects;
    
    public class Bank {
    	// 假设一个账户有1000块钱  
    	static double money = 1000;
    	// 柜台Counter取钱的方法  
    	private void Counter(double money) {
    		Bank.money -= money;
    		System.out.println("柜台取钱" + money + "元,还剩" + Bank.money + "元!");
    	}
    	// ATM取钱的方法  
    	private void ATM(double money) {
    		Bank.money -= money;
    		System.out.println("ATM取钱" + money + "元,还剩" + Bank.money + "元!");
    	}
    	
    	//提供一个对外取款途径,防止直接调取方法同时取款时,并发余额显示错误
    	public synchronized void outMoney(double money, String mode) throws Exception{
    		if(money > Bank.money){
    			//校验余额是否充足
    			throw new Exception("取款金额"+money+",余额只剩"+Bank.money+",取款失败");
    		}
    		if(Objects.equals(mode, "ATM")){
    			ATM(money);
    		} else {
    			Counter(money);
    		}
    	}
    
    }

    (二)创建一个PersonA类

    package com.thread.demo.demo2;
    
    public class PersonA extends Thread {
    
    	Bank bank;
    	
    	String mode;
    
    	public PersonA(Bank bank, String mode) {
    		this.mode = mode;
    		this.bank = bank;
    	}
    
    	public void run (){
    		while(bank.money >= 100){
    			try {
    				bank.outMoney(100, mode);
    			} catch (Exception e1) {
    				// TODO Auto-generated catch block
    				e1.printStackTrace();
    			}
    			try {
    				sleep(100);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    }

    (三)创建一个PersonB类

    package com.thread.demo.demo2;
    
    public class PersonB extends Thread {
    	Bank bank;
    	
    	String mode;
    
    	public PersonB(Bank bank, String mode) {
    		this.bank = bank;
    		this.mode = mode;
    	}
    
    	public void run() {
    		while (bank.money >= 200) {
    			try {
    				bank.outMoney(200, mode);
    			} catch (Exception e1) {
    				// TODO Auto-generated catch block
    				e1.printStackTrace();
    			}
    			try {
    				sleep(100);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		
    	}
    }

    (四)创建主方法的调用类

    package com.thread.demo.demo2;
    
    /**
     * 两个人AB通过一个账户A在柜台取钱和B在ATM机取钱
     * */
    public class MainClass {
    	public static void main(String[] args) {
    		Bank bank = new Bank();
    		// 实例化两个人,传入同一个银行的对象
    		PersonA a = new PersonA(bank, "Counter");
    		PersonB b = new PersonB(bank, "ATM");
    		a.start();
    		b.start();
    	}
    }
    运行结果:

    可以看到取完就停止运行了。

    3.龟兔赛跑问题

    龟兔赛跑:2000米 
    要求:
        (1)兔子每 0.1 秒 5 米的速度,每跑20米休息1秒;
        (2)乌龟每 0.1 秒跑 2 米,不休息;
        (3)其中一个跑到终点后另一个不跑了!
    程序设计思路:
        (1)创建一个Animal动物类,继承Thread,编写一个running抽象方法,重写run方法,把running方法在run方法里面调用。
        (2)创建Rabbit兔子类和Tortoise乌龟类,继承动物类
        (3)两个子类重写running方法
        (4)本题的第3个要求涉及到线程回调。需要在动物类创建一个回调接口,创建一个回调对象。

    (一)创建Animal动物类

    package com.thread.demo.demo3;
    
    public abstract class Animal extends Thread {
    	public int length = 2000;// 比赛长度
    
    	public abstract void runing();
    
    	@Override
    	public void run() {
    		super.run();
    		while (length > 0) {
    			runing();
    		}
    	}
    
    	// 在需要回调数据的地方(两个子类需要),声明一个接口
    	public static interface Calltoback {
    		public void win();
    	}
    
    	// 2.创建接口对象
    	public Calltoback calltoback;
    
    }

    (二)创建Rabbit兔子类

    package com.thread.demo.demo3;
    
    public class Rabbit extends Animal {
    
    	public Rabbit() {
    		setName("兔子");
    	}
    
    	@Override
    	public void runing() {
    		//兔子速度
    		int dis = 5;
    		length -= dis;
    
    		System.out.println("兔子跑了" + dis + "米,距离终点还有" + length + "米");
    		if (length <= 0) {
    			length = 0;
    			System.out.println("兔子获得了胜利");
    			// 给回调对象赋值,让乌龟不要再跑了
    			if (calltoback != null) {
    				calltoback.win();
    			}
    		}
    
    		try {
    			if ((2000 - length) % 20 == 0) {	// 每20米休息一次,休息时间是1秒
    				sleep(1000);
    			} else {				//没0.1秒跑5米
    				sleep(100);
    			}
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    }

    (三)创建Tortoise乌龟类

    package com.thread.demo.demo3;
    
    public class Tortoise extends Animal {
    	public Tortoise() {
    		setName("乌龟");// Thread的方法,给线程赋值名字
    	}
    
    	// 重写running方法,编写乌龟的奔跑操作
    	@Override
    	public void runing() {
    		// 乌龟速度
    		int dis = 2;
    		length -= dis;
    		System.out.println("乌龟跑了" + dis + "米,距离终点还有" + length + "米");
    		if (length <= 0) {
    			length = 0;
    			System.out.println("乌龟获得了胜利");
    			// 让兔子不要在跑了
    			if (calltoback != null) {
    				calltoback.win();
    			}
    		}
    		try {
    			sleep(100);						//没0.1秒跑2米
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    }

    (四)创建一个让动物线程停止的类,这里要实现回调接口

    package com.thread.demo.demo3;
    
    import com.thread.demo.demo3.Animal.Calltoback;
    
    public class LetOneStop implements Calltoback {
    	// 动物对象
    	Animal an;
    
    	// 获取动物对象,可以传入兔子或乌龟的实例
    	public LetOneStop(Animal an) {
    		this.an = an;
    	}
    
    	// 让动物的线程停止
    	@Override
    	public void win() {
    		// 线程停止
    		an.stop();
    	}
    }

    (五)创建一个主方法调用类

    package com.thread.demo.demo3;
    
    public class MainClass {
    	/**
    	 * 龟兔赛跑:2000米
    	 */
    	public static void main(String[] args) {
    		// 实例化乌龟和兔子
    		Tortoise tortoise = new Tortoise();
    		Rabbit rabbit = new Rabbit();
    		// 回调方法的使用,谁先调用calltoback方法,另一个就不跑了
    		LetOneStop letOneStop1 = new LetOneStop(tortoise);
    		// 让兔子的回调方法里面存在乌龟对象的值,可以把乌龟stop
    		rabbit.calltoback = letOneStop1;
    		LetOneStop letOneStop2 = new LetOneStop(rabbit);
    		// 让乌龟的回调方法里面存在兔子对象的值,可以把兔子stop
    		tortoise.calltoback = letOneStop2;
    		// 开始跑
    		tortoise.start();
    		rabbit.start();
    	}
    
    }

    运行结果:


    4. 线程示例总结

        (1)代码块锁是一个防止数据发生错误的一个重要手段;

        (2)对象的统一性是非常重要的,这要想到对象的传入问题,要操作的对象只能new一次,其他的操作都是对这个传入的对象进行的,才能保证数据一致性,完整性和正确性。

    展开全文
  • Java多线程编程总结

    2010-04-26 00:16:34
    Java多线程编程总结Java多线程编程总结Java多线程编程总结Java多线程编程总结Java多线程编程总结Java多线程编程总结
  • Java多线程编程Java多线程编程Java多线程编程Java多线程编程Java多线程编程Java多线程编程
  • java多线程编程,带完整目录 java多线程编程,带完整目录
  • JAVA多线程编程技术PDF

    2018-08-28 14:43:48
    JAVA多线程编程技术PDF,是最经典的那个版本,多线程的所有知识点完爆读者
  • Java多线程编程实战指南 设计模式篇 Java多线程编程实战指南 设计模式篇
  • Java多线程编程详解

    2009-03-07 15:09:52
    Java多线程编程详解~Java多线程编程详解~Java多线程编程详解~Java多线程编程详解
  • Java多线程编程深入详解,深入讲解java多线程编程思想原理,解决多线程编程中常见的问题
  • 主要介绍了 java多线程编程技术详解和实例代码的相关资料,需要的朋友可以参考下
  • java多线程编程讲解

    2009-11-01 22:05:00
    java多线程编程,ppt+源代码讲解。java多线程编程,ppt+源代码讲解。java多线程编程,ppt+源代码讲解。
  • 本例来自《java多线程编程调试模式》: 题意:模拟流水线上的工人,  工人一直在流水线上作业,零件(可看作客户端发的请求)一到达,工人就开始进行工作,无零件时工作处于等待状态 具体的业务代码有详注释: ...

    一.本例来自《java多线程编程调试模式》:

    题意:模拟流水线上的工人,

     工人一直在流水线上作业,零件(可看作客户端发的请求)一到达,工人就开始进行工作,无零件时工作处于等待状态

    具体的业务代码有详注释:

    一测试类:
    package worker.thread.pattern;
    
    public class Main {
        public static void main(String[] args) {
        	 Channel channel = new Channel(5);   // Worker Thread数量
             channel.startWorkers();
             ClientThread alice = new ClientThread("Alice", channel);
             ClientThread bobby = new ClientThread("Bobby", channel);
             ClientThread chris = new ClientThread("Chris", channel);
             alice.start();
             bobby.start();
             chris.start();
    
             try {
                 Thread.sleep(5000);
             } catch (InterruptedException e) {
             }
             alice.stopThread();
             bobby.stopThread();
             chris.stopThread();
             channel.stopAllWorkers();
        }
    }
    

    2.客户端类:主要发送工作请求
    package worker.thread.pattern;
    
    import java.util.Random;
    
    /**
     * 不停的发送请求给工人类
     * 
     * 1.创建请求实例,并将实例发送给管理工人线程的类
     * 
     * @author lxb
     *
     */
    public class ClientThread extends Thread {
    
    	private final Channel channel;
    	private static final Random random = new Random();
    
    	private volatile boolean terminated = false; // 停止请求标志
    
    	public ClientThread(String name, Channel channel) {
    		super(name);
    		this.channel = channel;
    	}
    
    	public void run() {
    		try {
    			for (int i = 0; !terminated; i++) {
    				try {
    					Request request = new Request(getName(), i);
    					channel.putRequest(request);
    					Thread.sleep(random.nextInt(1000));
    				} catch (InterruptedException e) {
    					terminated = true;
    				}
    			}
    		} finally {
    			System.out.println(Thread.currentThread().getName()
    					+ " is terminated.");
    		}
    	}
    
    	public void stopThread() {
    		terminated = true;
    		interrupt();
    	}
    }
    

    3.请求对象:

    package worker.thread.pattern;
    
    import java.util.Random;
    
    /**
     * 请求实体类
     * @author lxb
     *
     */
    public class Request {
    
    	private final String name; //  
        private final int number;  // 
        private static final Random random = new Random();
        public Request(String name, int number) {
            this.name = name;
            this.number = number;
        }
        public void execute() {
            System.out.println(Thread.currentThread().getName() + " executes " + this);
            try {
                Thread.sleep(random.nextInt(1000));
            } catch (InterruptedException e) {
            }
        }
        public String toString() {
            return "[ Request from " + name + " No." + number + " ]";
        }
    }
    

    4.请求队列与工人线程管理类:
    package worker.thread.pattern;
    
    /**
     * 用来接受客户端线程发来的请求、将请求传递给工人线程,所以至少需要以下数据结构:
     * 1.一个队列来保存客户端发来的请求,还必须提供两个接口,一个putRequest保存请求, 另一个是取出请求takeRequest
     * 2.线程池来管理各个工人线程,这个池可以是一个线程数组,数组大小可自定义
     * 
     * @author lxb
     *
     */
    public class Channel {
    
    	private static final int MAX_REQUEST = 100; // 假设最大的请求队列值
    
    	private final Request[] requestQueue; // 保存的请求队列
    
    	private int tail;
    	private int head;
    	private int count; // 请求队列中的请求数量
    
    	private final WorkerThread[] threadPool; // 工人线程池
    
    	public Channel(int threads) {
    
    		this.requestQueue = new Request[MAX_REQUEST];
    		this.head = 0;
    		this.count = 0;
    		this.tail = 0;
    		threadPool = new WorkerThread[threads];
    
    		for (int i = 0; i < threadPool.length; i++) {
    			 threadPool[i] = new WorkerThread("Worker-" + i, this);
    		}
    	}
    	
    	/**
    	 * 开启工作线程
    	 */
    	public void startWorkers() {
    		for (int i = 0; i < threadPool.length; i++) {
    			threadPool[i].start();
    		}
    	}
    	
    	public void stopAllWorkers(){
    		for(int i=0;i<threadPool.length;i++){
    			threadPool[i].stopThread();
    		}
    	}
    
    	/**
    	 * 保存客户端发来的工作请求
    	 * 
    	 * @param request
    	 * @throws InterruptedException 
    	 */
    	public synchronized void putRequest(Request request) throws InterruptedException {
    		while (count >= requestQueue.length) {
    			wait();
    		}
    
    		requestQueue[tail] = request;
    
    		tail = (tail + 1) % requestQueue.length;
    
    		count++;
    
    		notifyAll();
    	}
    
    	public synchronized Request takeRequest() throws InterruptedException {
    		while (count <= 0) {
    			wait();
    		}
    
    		Request request = requestQueue[head];
    		head = (head + 1) % requestQueue.length;
    
    		count--;
    		notifyAll();
    		return request;
    	}
    
    }
    

    5工人线程:

    package worker.thread.pattern;
    
    /**
     * 工作线程,处理客户端发来的具体的工作请求
     * @author lxb
     *
     */
    public class WorkerThread extends Thread{
    
    	private final Channel channel;
    	private volatile boolean terminated = false;	//停止请求标志
    	
    	public WorkerThread(String name,Channel channel){
    		super(name);
    		this.channel = channel;
    	}
    	
    	public void run() {
            try {
                while (!terminated) {
                    try {                                           
                        Request request = channel.takeRequest();    
                        request.execute();                          
                    } catch (InterruptedException e) {
                        terminated = true;
                    }                                               
                }
            } finally {
                System.out.println(Thread.currentThread().getName() + " is terminated.");
            }
        }
        public void stopThread() {
            terminated = true;
            interrupt();
        }
    }
    




    展开全文
  • Java多线程编程实战指南(核心篇)》以基本概念、原理与方法为主线,辅以丰富的实战案例和生活化实例,并从Java虚拟机、操作系统和硬件多个层次与角度出发,循序渐进、系统地介绍Java平台下的多线程编程核心技术及...
  • java 多线程编程指南

    2012-03-10 21:34:00
    java多线程编程指南,一个比较高级和深入的java编程学习资料。
  • 汪文君JAVA多线程编程实战(完整不加密)。 汪文君JAVA多线程编程实战(完整不加密),连接挂了留言, 我补 java 汪文君 多线程 视频教程 实战。
  • 内容索引:Java源码,书籍源码,多线程编程实例 这是Java多线程编程实例一书的全部随书源码,这本书是很早的JAVA多线程编程指导书,虽然很老但是很经典,直到现在还很热,很有参考价值。
  • Java多线程编程实战指南-核心篇Java多线程编程实战指南-核心篇
  • 主要介绍了Java多线程编程之ThreadLocal线程范围内的共享变量,本文讲解了ThreadLocal的作用和目的、ThreadLocal的应用场景、ThreadLocal的使用实例等,需要的朋友可以参考下
  • java多线程编程详解

    2010-08-16 21:40:02
    详细讲解了java多线程编程,详细java多线程例子
  • Java多线程编程核心技术》书上案例代码 基本和书上是一样的。 每一部分都是按照书上说 创建什么项目 就直接用做包最后一层的名字,全部小写,中间加下划线。java不推荐包名大小写混用。 part几就是第几章,第一章...

    java-multi-thread-ilss

    Github地址:https://github.com/imyiren/java-multi-thread

    《Java多线程编程核心技术》书上案例代码

    基本和书上是一样的。

    每一部分都是按照书上说 创建什么项目 就直接用做包最后一层的名字,全部小写,中间加下划线。java不推荐包名大小写混用。
    part几就是第几章,第一章没有,自己过一遍就好了。如果有想共享的。欢迎~
    代码的个别地方我有改动。每一个小demo里面都有我自己的理解,和书上的一些关键点注释,一般在main方法里面,少部分可能在类里面
    展开全文
  • Java多线程编程实战指南(设计模式篇)》采用Java(JDK1.6)语言和UML 为描述语言,并结合作者多年工作经历的相关实战案例,介绍了多线程环境下常用设计模式的来龙去脉:各个设计模式是什么样的及其典型的实际应用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 424,004
精华内容 169,601
关键字:

java多线程编程

java 订阅