http://ayufox.javaeye.com/blog/391812

关键字: http rest

　　生产者进程(进程由多个线程组成)生产信息，例如它可以是计算进程。消费
者进程使用信息，它可以是输出打印进程。由于生产者和消费者彼此独立，且运
行速度不确定，所以很可能出现生产者已产生了信息而消费者却没有来得及接受
信息这种情况。为此，需要引入由一个或者若干个存储单元组成的临时存储区，
以便存放生产者所产生的信息，平滑进程间由于速度不确定所带来的问题。这个
临时存储区叫做缓冲区，通常用一维数组来表示。

　　由一个或若干个存储单元组成的缓冲区叫作“有穷缓冲区”。下面我们来分
析一下有穷缓冲的生产者和消费者的例子。

　　假设有多个生产者和多个消费者，它们共享一个具有n个存储单元的有穷缓冲
区Buffer(0……n-1)，这是一个环形队列。其队尾指针Rear指向当前信息应存放
的位置(Buffer[Rear])，队首指针Front指向当前取出信息的位置(Buffer[front
])。生产者进程总是把信息存放在Buffer[Rear]中，消费者进程则总是从Buffer
[Rear]中取出信息。如果想使生产者进程和消费者进程协调合作，则必须使它们
遵循如下规则:

　　1) 只要缓冲区有存储单元，生产者都可往其中存放信息；当缓冲区已满时，
若任意生产者提出写要求，则都必须等待；

　　2) 只要缓冲区中有消息可取，消费者都可从缓冲区中取出消息；当缓冲区为
空时，若任意消费者想取出信息，则必须等待；

　　3) 生产者们和消费者们不能同时读、写缓冲区。

　　用JAVA 实现“生产者－消费者”问题的代码如下:

public class ProducerConsumer {
 public static void main(String[] args) {
  SyncStack ss = new SyncStack();
  Producer p = new Producer(ss);
  Consumer c = new Consumer(ss);
  new Thread(p).start();
  new Thread(p).start();
  new Thread(p).start();
  new Thread(c).start();
 }
}

class WoTou {
 int id;
 WoTou(int id) {
  this.id = id;
 }
 public String toString() {
  return "WoTou : " + id;
 }
}

class SyncStack {
 int index = 0;
 WoTou[] arrWT = new WoTou[6];
 
 public synchronized void push(WoTou wt) {
  while(index == arrWT.length) {
   try {
    this.wait();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  this.notifyAll(); 
  arrWT[index] = wt;
  index ++;
 }
 
 public synchronized WoTou pop() {
  while(index == 0) {
   try {
    this.wait();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  this.notifyAll();
  index--;
  return arrWT[index];
 }
}

class Producer implements Runnable {
 SyncStack ss = null;
 Producer(SyncStack ss) {
  this.ss = ss;
 }
 
 public void run() {
  for(int i=0; i<20; i++) {
   WoTou wt = new WoTou(i);
   ss.push(wt);
System.out.println("生产了：" + wt);
   try {
    Thread.sleep((int)(Math.random() * 200));
   } catch (InterruptedException e) {
    e.printStackTrace();
   }  
  }
 }
}

class Consumer implements Runnable {
 SyncStack ss = null;
 Consumer(SyncStack ss) {
  this.ss = ss;
 }
 
 public void run() {
  for(int i=0; i<20; i++) {
   WoTou wt = ss.pop();
System.out.println("消费了: " + wt);
   try {
    Thread.sleep((int)(Math.random() * 1000));
   } catch (InterruptedException e) {
    e.printStackTrace();
   }  
  }
 }
}

生产者消费者问题是研究多线程程序时绕不开的问题，它的描述是有一块生产者和消费者共享的有界缓冲区，生产者往缓冲区放入产品，消费者从缓冲区取走产品，这个过程可以无休止的执行，不能因缓冲区满生产者放不进产品而终止，也不能因缓冲区空消费者无产品可取而终止。

       解决生产者消费者问题的方法有两种，一种是采用某种机制保持生产者和消费者之间的同步，一种是在生产者和消费者之间建立一个管道。前一种有较高的效率并且可控制性较好，比较常用，后一种由于管道缓冲区不易控制及被传输数据对象不易封装等原因，比较少用。
       同步问题的核心在于，CPU是按时间片轮询的方式执行程序，我们无法知道某一个线程是否被执行、是否被抢占、是否结束等，因此生产者完全可能当缓冲区已满的时候还在放入产品，消费者也完全可能当缓冲区为空时还在取出产品。
       现在同步问题的解决方法一般是采用信号或者加锁机制，即生产者线程当缓冲区已满时放弃自己的执行权，进入等待状态，并通知消费者线程执行。消费者线程当缓冲区已空时放弃自己的执行权，进入等待状态，并通知生产者线程执行。这样一来就保持了线程的同步，并避免了线程间互相等待而进入死锁状态。
       JAVA语言提供了独立于平台的线程机制，保持了”write once, run anywhere”的特色。同时也提供了对同步机制的良好支持。
       在JAVA中，一共有四种方法支持同步，其中三个是同步方法，一个是管道方法。
1.       方法wait()/notify()
2.       方法await()/signal()
3.       阻塞队列方法BlockingQueue
4.       管道方法PipedInputStream/PipedOutputStream
下面我们看各个方法的实现：
1.       方法wait()/notify()
wait()和notify()是根类Object的两个方法，也就意味着所有的JAVA类都会具有这个两个方法，为什么会被这样设计呢？我们可以认为所有的对象默认都具有一个锁，虽然我们看不到，也没有办法直接操作，但它是存在的。
wait()方法表示：当缓冲区已满或空时，生产者或消费者线程停止自己的执行，放弃锁，使自己处于等待状态，让另一个线程开始执行；
notify()方法表示：当生产者或消费者对缓冲区放入或取出一个产品时，向另一个线程发出可执行通知，同时放弃锁，使自己处于等待状态。
下面是一个例子代码：
import java.util.LinkedList;

public class Sycn1...{
    private LinkedList<Object> myList =new LinkedList<Object>();
    private int MAX = 10;
   
    public Sycn1()...{
    }
   
    public void start()...{
            new Producer().start();
            new Consumer().start();
    }
   
    public static void main(String[] args) throws Exception...{
        Sycn1 s1 = new Sycn1();
        s1.start();
    }
   
    class Producer extends Thread...{       
        public void run()...{
            while(true)...{
                synchronized(myList)...{
                    try...{
                        while(myList.size() == MAX)...{
                            System.out.println("warning: it's full!");
                            myList.wait();
                        }
                        Object o = new Object();
                        if(myList.add(o))...{
                            System.out.println("Producer: " + o);
                            myList.notify();
                        }
                    }catch(InterruptedException ie)...{
                        System.out.println("producer is interrupted!");
                    }
                }
            }
        }
    }
   
    class Consumer extends Thread...{
        public void run()...{
            while(true)...{
                synchronized(myList)...{
                    try...{
                        while(myList.size() == 0)...{
                            System.out.println("warning: it's empty!");
                            myList.wait();
                        }
                        Object o = myList.removeLast();
                        System.out.println("Consumer: " + o);
                        myList.notify();
                    }catch(InterruptedException ie)...{
                        System.out.println("consumer is interrupted!");
                    }
                }
            }
        }
    }
   
}
2.       方法await()/signal()
在JDK5.0以后，JAVA提供了新的更加健壮的线程处理机制，包括了同步、锁定、线程池等等，它们可以实现更小粒度上的控制。await()和signal()就是其中用来做同步的两种方法，它们的功能基本上和wait()/notify()相同，完全可以取代它们，但是它们和新引入的锁定机制Lock直接挂钩，具有更大的灵活性。
下面是一个例子代码：
import java.util.LinkedList;

import java.util.concurrent.locks.*;

public class Sycn2...{
    private LinkedList<Object> myList = new LinkedList<Object>();
    private int MAX = 10;
    private final Lock lock = new ReentrantLock();
    private final Condition full = lock.newCondition();
    private final Condition empty = lock.newCondition();
   
    public Sycn2()...{
    }
   
    public void start()...{
            new Producer().start();
            new Consumer().start();
    }
   
    public static void main(String[] args) throws Exception...{
        Sycn2 s2 = new Sycn2();
        s2.start();
    }
   
    class Producer extends Thread...{       
        public void run()...{
            while(true)...{
                lock.lock();
                try...{
                    while(myList.size() == MAX)...{
                        System.out.println("warning: it's full!");
                        full.await();
                    }
                    Object o = new Object();
                    if(myList.add(o))...{
                        System.out.println("Producer: " + o);
                        empty.signal();
                    }
                }catch(InterruptedException ie)...{
                    System.out.println("producer is interrupted!");
                }finally...{
                    lock.unlock();
                }
            }
        }
    }
   
    class Consumer extends Thread...{
        public void run()...{
            while(true)...{
                lock.lock();
                try...{
                    while(myList.size() == 0)...{
                        System.out.println("warning: it's empty!");
                        empty.await();
                    }
                    Object o = myList.removeLast();
                    System.out.println("Consumer: " + o);
                    full.signal();
                }catch(InterruptedException ie)...{
                    System.out.println("consumer is interrupted!");
                }finally...{
                    lock.unlock();
                }
            }
        }
    }
   
}
3.       阻塞队列方法BlockingQueue
BlockingQueue也是JDK5.0的一部分，它是一个已经在内部实现了同步的队列，实现方式采用的是我们的第2种await()/signal()方法。它可以在生成对象时指定容量大小。
它用于阻塞操作的是put()和take()方法。
put()方法类似于我们上面的生产者线程，容量最大时，自动阻塞。
take()方法类似于我们上面的消费者线程，容量为0时，自动阻塞。
下面是一个例子代码：
import java.util.concurrent.*;

public class Sycn3...{
    private LinkedBlockingQueue<Object> queue = new LinkedBlockingQueue<Object>(10);
    private int MAX = 10;
   
    public Sycn3()...{
    }
   
    public void start()...{
            new Producer().start();
            new Consumer().start();
    }
   
    public static void main(String[] args) throws Exception...{
        Sycn3 s3 = new Sycn3();
        s3.start();
    }
   
    class Producer extends Thread...{       
        public void run()...{
            while(true)...{
                //synchronized(this){
                try...{
                    if(queue.size() == MAX)
                        System.out.println("warning: it's full!");
                    Object o = new Object();
                    queue.put(o);
                    System.out.println("Producer: " + o);
                    }catch(InterruptedException e)...{
                        System.out.println("producer is interrupted!");
                    }
                //}
            }
        }
    }
   
    class Consumer extends Thread...{
        public void run()...{
            while(true)...{
                //synchronized(this){
                try...{
                    if(queue.size() == 0)
                        System.out.println("warning: it's empty!");
                    Object o = queue.take();
                    System.out.println("Consumer: " + o);
                    }catch(InterruptedException e)...{
                        System.out.println("producer is interrupted!");
                    }
                //}
            }
        }
    }
   
}
你发现这个例子中的问题了吗？
如果没有，我建议你运行一下这段代码，仔细观察它的输出，是不是有下面这个样子的？为什么会这样呢？
…
warning: it's full!
Producer: java.lang.object@4526e2a
…
你可能会说这是因为put()和System.out.println()之间没有同步造成的，我也这样认为，我也这样认为，但是你把run()中的synchronized前面的注释去掉，重新编译运行，有改观吗？没有。为什么？
这是因为，当缓冲区已满，生产者在put()操作时，put()内部调用了await()方法，放弃了线程的执行，然后消费者线程执行，调用take()方法，take()内部调用了signal()方法，通知生产者线程可以执行，致使在消费者的println()还没运行的情况下生产者的println()先被执行，所以有了上面的输出。run()中的synchronized其实并没有起什么作用。
对于BlockingQueue大家可以放心使用，这可不是它的问题，只是在它和别的对象之间的同步有问题。
对于这种多重嵌套同步的问题，以后再谈吧，欢迎大家讨论啊！
4.       管道方法PipedInputStream/PipedOutputStream
这个类位于java.io包中，是解决同步问题的最简单的办法，一个线程将数据写入管道，另一个线程从管道读取数据，这样便构成了一种生产者/消费者的缓冲区编程模式。
下面是一个例子代码，在这个代码我没有使用Object对象，而是简单的读写字节值，这是因为PipedInputStream/PipedOutputStream不允许传输对象，这是JAVA本身的一个bug,具体的大家可以看sun的解释：http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4131126
import java.io.*;

public class Sycn4...{
    private PipedOutputStream pos;
    private PipedInputStream pis;
    //private ObjectOutputStream oos;
    //private ObjectInputStream ois;
   
    public Sycn4()...{
        try...{
            pos = new PipedOutputStream();
            pis = new PipedInputStream(pos);
            //oos = new ObjectOutputStream(pos);
            //ois = new ObjectInputStream(pis);
        }catch(IOException e)...{
            System.out.println(e);
        }
    }
   
    public void start()...{
        new Producer().start();
        new Consumer().start();
    }
   
    public static void main(String[] args) throws Exception...{
        Sycn4 s4 = new Sycn4();
        s4.start();
    }
   
    class Producer extends Thread...{
        public void run() ...{
            try...{
                while(true)...{
                    int b = (int) (Math.random() * 255);
                    System.out.println("Producer: a byte, the value is " + b);
                    pos.write(b);
                    pos.flush();
                    //Object o = new MyObject();
                    //oos.writeObject(o);
                    //oos.flush();
                    //System.out.println("Producer: " + o);
                }
            }catch(Exception e)...{
                //System.out.println(e);
                e.printStackTrace();
            }finally...{
                try...{
                    pos.close();
                    pis.close();
                    //oos.close();
                    //ois.close();
                }catch(IOException e)...{
                    System.out.println(e);
                }
            }
        }
    }
   
    class Consumer extends Thread...{
        public void run()...{
            try...{
                while(true)...{
                    int b = pis.read();
                    System.out.println("Consumer: a byte, the value is " + String.valueOf(b));
                    //Object o = ois.readObject();
                    //if(o != null)
                        //System.out.println("Consumer: " + o);
                }
            }catch(Exception e)...{
                //System.out.println(e);
                e.printStackTrace();
            }finally...{
                try...{
                    pos.close();
                    pis.close();
                    //oos.close();
                    //ois.close();
                }catch(IOException e)...{
                    System.out.println(e);
                }
            }
        }
    }
   
    //class MyObject implements Serializable {
    //}
}

出处：http://blog.csdn.net/JaunLee/archive/2008/02/01/2077291.aspx

原文地址:http://tech.e800.com.cn/articles/2009/79/1247104593971_1.html
JVM内存由 Perm 和 Heap 组成. 其中
Heap = {Old + NEW = { Eden , from, to } }
JVM内存模型中分两大块，一块是 NEW Generation, 另一块是Old Generation. 在New Generation中，有一个叫Eden的空间，主要是用来存放新生的对象，还有两个Survivor Spaces（from,to）, 它们用来存放每次垃圾回收后存活下来的对象。在Old Generation中，主要存放应用程序中生命周期长的内存对象，还有个Permanent Generation，主要用来放JVM自己的反射对象，比如类对象和方法对象等。

垃圾回收描述：

在New Generation块中，垃圾回收一般用Copying的算法，速度快。每次GC的时候，存活下来的对象首先由Eden拷贝到某个Survivor Space, 当Survivor Space空间满了后, 剩下的live对象就被直接拷贝到Old Generation中去。因此，每次GC后，Eden内存块会被清空。在Old Generation块中，垃圾回收一般用mark-compact的算法，速度慢些，但减少内存要求.
垃圾回收分多级，0级为全部(Full)的垃圾回收，会回收OLD段中的垃圾；1级或以上为部分垃圾回收，只会回收NEW中的垃圾，内存溢出通常发生于OLD段或Perm段垃圾回收后，仍然无内存空间容纳新的Java对象的情况。

当一个URL被访问时，内存申请过程如下：
A. JVM会试图为相关Java对象在Eden中初始化一块内存区域
B. 当Eden空间足够时，内存申请结束。否则到下一步
C. JVM试图释放在Eden中所有不活跃的对象（这属于1或更高级的垃圾回收）, 释放后若Eden空间仍然不足以放入新对象，则试图将部分Eden中活跃对象放入Survivor区
D. Survivor区被用来作为Eden及OLD的中间交换区域，当OLD区空间足够时，Survivor区的对象会被移到Old区，否则会被保留在Survivor区
E. 当OLD区空间不够时，JVM会在OLD区进行完全的垃圾收集（0级）
F. 完全垃圾收集后，若Survivor及OLD区仍然无法存放从Eden复制过来的部分对象，导致JVM无法在Eden区为新对象创建内存区域，则出现”out of memory错误”

JVM调优建议:

ms/mx：定义YOUNG+OLD段的总尺寸，ms为JVM启动时YOUNG+OLD的内存大小；mx为最大可占用的YOUNG+OLD内存大小。在用户生产环境上一般将这两个值设为相同，以减少运行期间系统在内存申请上所花的开销。
NewSize/MaxNewSize：定义YOUNG段的尺寸，NewSize为JVM启动时YOUNG的内存大小；MaxNewSize为最大可占用的YOUNG内存大小。在用户生产环境上一般将这两个值设为相同，以减少运行期间系统在内存申请上所花的开销。
PermSize/MaxPermSize：定义Perm段的尺寸，PermSize为JVM启动时Perm的内存大小；MaxPermSize为最大可占用的Perm内存大小。在用户生产环境上一般将这两个值设为相同，以减少运行期间系统在内存申请上所花的开销。
SurvivorRatio：设置Survivor空间和Eden空间的比例

内存溢出的可能性

1. OLD段溢出
这种内存溢出是最常见的情况之一，产生的原因可能是：
1) 设置的内存参数过小(ms/mx, NewSize/MaxNewSize)
2) 程序问题
单个程序持续进行消耗内存的处理，如循环几千次的字符串处理，对字符串处理应建议使用StringBuffer。此时不会报内存溢出错，却会使系统持续垃圾收集，无法处理其它请求，相关问题程序可通过Thread Dump获取（见系统问题诊断一章）单个程序所申请内存过大，有的程序会申请几十乃至几百兆内存，此时JVM也会因无法申请到资源而出现内存溢出，对此首先要找到相关功能，然后交予程序员修改，要找到相关程序，必须在Apache日志中寻找。
当Java对象使用完毕后，其所引用的对象却没有销毁，使得JVM认为他还是活跃的对象而不进行回收，这样累计占用了大量内存而无法释放。由于目前市面上还没有对系统影响小的内存分析工具，故此时只能和程序员一起定位。

2. Perm段溢出
通常由于Perm段装载了大量的Servlet类而导致溢出，目前的解决办法：
1) 将PermSize扩大，一般256M能够满足要求
2) 若别无选择，则只能将servlet的路径加到CLASSPATH中，但一般不建议这么处理

3. C Heap溢出
系统对C Heap没有限制，故C Heap发生问题时，Java进程所占内存会持续增长，直到占用所有可用系统内存

其他：

JVM有2个GC线程。第一个线程负责回收Heap的Young区。第二个线程在Heap不足时，遍历Heap，将Young 区升级为Older区。Older区的大小等于-Xmx减去-Xmn，不能将-Xms的值设的过大，因为第二个线程被迫运行会降低JVM的性能。
为什么一些程序频繁发生GC？有如下原因：
l 程序内调用了System.gc()或Runtime.gc()。
l 一些中间件软件调用自己的GC方法，此时需要设置参数禁止这些GC。
l Java的Heap太小，一般默认的Heap值都很小。
l 频繁实例化对象，Release对象。此时尽量保存并重用对象，例如使用StringBuffer()和String()。
如果你发现每次GC后，Heap的剩余空间会是总空间的50%，这表示你的Heap处于健康状态。许多Server端的Java程序每次GC后最好能有65%的剩余空间。
经验之谈：
1．Server端JVM最好将-Xms和-Xmx设为相同值。为了优化GC，最好让-Xmn值约等于-Xmx的1/3[2]。
2．一个GUI程序最好是每10到20秒间运行一次GC，每次在半秒之内完成[2]。
注意：
1．增加Heap的大小虽然会降低GC的频率，但也增加了每次GC的时间。并且GC运行时，所有的用户线程将暂停，也就是GC期间，Java应用程序不做任何工作。
2．Heap大小并不决定进程的内存使用量。进程的内存使用量要大于-Xmx定义的值，因为Java为其他任务分配内存，例如每个线程的Stack等。
2．Stack的设定
每个线程都有他自己的Stack。

-Xss

每个线程的Stack大小
Stack的大小限制着线程的数量。如果Stack过大就好导致内存溢漏。-Xss参数决定Stack大小，例如-Xss1024K。如果Stack太小，也会导致Stack溢漏。
3．硬件环境
硬件环境也影响GC的效率，例如机器的种类，内存，swap空间，和CPU的数量。
如果你的程序需要频繁创建很多transient对象，会导致JVM频繁GC。这种情况你可以增加机器的内存，来减少Swap空间的使用[2]。
4．4种GC
第一种为单线程GC，也是默认的GC。，该GC适用于单CPU机器。
第二种为Throughput GC，是多线程的GC，适用于多CPU，使用大量线程的程序。第二种GC与第一种GC相似，不同在于GC在收集Young区是多线程的，但在Old区和第一种一样，仍然采用单线程。-XX:+UseParallelGC参数启动该GC。
第三种为Concurrent Low Pause GC，类似于第一种，适用于多CPU，并要求缩短因GC造成程序停滞的时间。这种GC可以在Old区的回收同时，运行应用程序。-XX:+UseConcMarkSweepGC参数启动该GC。

第四种为Incremental Low Pause GC，适用于要求缩短因GC造成程序停滞的时间。这种GC可以在Young区回收的同时，回收一部分Old区对象。-Xincgc参数启动该GC。

The org.snmp4j classes are capable of creating, sending, and receiving SNMPv1/v2c/v3 messages. A SNMP message is composed of its message header and its PDU payload. This package contains three main groups of classes and interfaces:

• Classes for SNMP message and target creation
• Classes for SNMP message sending (command generation)
• Classes for SNMP message dispatching (command responding)

The following UML package diagram illustrates the dependencies between the packages of the core SNMP4J API. Users of the API normally only need to use the org.snmp4j and the org.snmp4j.smi packages directly.

The following UML class diagram shows the most important classes of the org.snmp4j package and their relationships (relationships to other packages are not shown):.

SNMP Messages and Targets

To exchange a SNMP message with a remote system, that system has to be identified, retransmission, and timeout policy information about the message exchange has to be specified. A remote system is specified with SNMP4J by creating a Target instance appropriate for the SNMP protocol to be used.

• For SNMPv1 and SNMPv2c the CommunityTarget has to be used which provides community information in addition to the address, retransmission, and timeout policy information defined by the Target interface.
• For SNMPv3 the UserTarget has to be used instead. It extends the SecureTarget abstract class and provides the following User Based Security Model (USM) user information: security name, security level, security model (i.e. USM), and authoritative engine ID.

A SNMP message consists of the message's payload, the SNMP Protocol Data Unit (PDU) and a message header. Simplified said, in SNMP4J the message header information is represented by Target instances and the PDU is represented by one of the following classes:

• PDUv1 (SNMPv1)
• PDU (SNMPv2c)
• ScopedPDU (SNMPv3)

PDU Examples (PDU 使用的例子)

• SNMPv1/v2c GETNEXT PDU

  import org.snmp4j.PDU;
      import org.snmp4j.smi.*;
      ...
      PDU pdu = new PDU();
      pdu.add(new VariableBinding(new OID("1.3.6.1.2.1.1.1"))); // sysDescr
      pdu.add(new VariableBinding(new OID("1.3.6.1.2.1.2.1"))); // ifNumber
      pdu.setType(PDU.GETNEXT);
      ...
      

• SNMPv3 GETBULK PDU

  import org.snmp4j.ScopedPDU;
      import org.snmp4j.smi.*;
      ...
      ScopedPDU pdu = new ScopedPDU();
      pdu.add(new VariableBinding(new OID("1.3.6.1.2.1.2.1"))); // ifNumber
      pdu.add(new VariableBinding(new OID("1.3.6.1.2.1.2.2.1.10"))); // ifInOctets
      pdu.add(new VariableBinding(new OID("1.3.6.1.2.1.2.2.1.16"))); // ifOutOctets
      pdu.setType(PDU.GETBULK);
      pdu.setMaxRepetitions(50);
      // Get ifNumber only once
      pdu.setNonRepeaters(1);
      // set context non-default context (default context does not need to be set)
      pdu.setContextName(new OctetString("subSystemContextA"));
      // set non-default context engine ID (to use targets authoritative engine ID
      // use an empty (size == 0) octet string)
      pdu.setContextEngineID(OctetString.fromHexString("80:00:13:70:c0:a8:01:0d"));
      ...
      

• SNMPv1 TRAP PDU ()

  import org.snmp4j.PDUv1;
      ...
      PDUv1 pdu = new PDUv1();
      pdu.setType(PDU.V1TRAP);
      pdu.setGenericTrap(PDUv1.COLDSTART);
      ...
      

• SNMPv2c/SNMPv3 INFORM PDU

  import org.snmp4j.ScopedPDU;
      ...
      ScopedPDU pdu = new ScopedPDU();
      pdu.setType(PDU.INFORM);
      // sysUpTime
      long sysUpTime = (System.currentTimeMillis() - startTime) / 10;
      pdu.add(new VariableBinding(SnmpConstants.sysUpTime, new TimeTicks(sysUpTime)));
      pdu.add(new VariableBinding(SnmpConstants.snmpTrapOID, SnmpConstants.linkDown));
      // payload
      pdu.add(new VariableBinding(new OID("1.3.6.1.2.1.2.2.1.1"+downIndex),
      new Integer32(downIndex)));
      ...
      

Target Examples (对象例子)

• Community Target

  CommunityTarget target = new CommunityTarget();
      target.setCommunity(new OctetString("public"));
      target.setAddress(targetAddress);
      target.setVersion(SnmpConstants.version1);
      

• User Target

  UserTarget target = new UserTarget();
      target.setAddress(targetAddress);
      target.setRetries(1);
      // set timeout to 500 milliseconds -> 2*500ms = 1s total timeout
      target.setTimeout(500);
      target.setVersion(SnmpConstants.version3);
      target.setSecurityLevel(SecurityLevel.AUTH_PRIV);
      target.setSecurityName(new OctetString("MD5DES"));
      

Sending SNMP messages

SNMP message are sent with SNMP4J by using a instance of the SNMP Session interface. The default implementation of this interface is the Snmp class.

To setup a Snmp instance it is sufficient to call its constructor with a TransportMapping instance. The transport mapping is used by the SNMP session to send (and receive) SNMP message to a remote systems by using a transport protocol, for example the User Datagram Protocol (UDP).

A SNMP4J Snmp instance supports SNMP v1, v2c, and v3 by default. By sub-classing Snmp other combinations of those SNMP protocol versions can be supported.

With SNMP4J, SNMP messages can be sent synchronously (blocking) and asynchronously (non-blocking). The Snmp class does not use an internal thread to process responses on asynchronous and synchronous requests. Nevertheless it uses the receiver threads of the transport mappings to process responses.

Asynchronous responses are returned by calling a callback method on an object instance that implements the ResponseListener interface. The callback is carried out on behalf of the transport mapping thread that received the response packet from the wire. Thus, if the called method blocks, the delivery of synchronous and asynchronous messages received on the listen port of that transport mapping will be also blocked. Other transport mapping will not be affected. Blocking can be avoided by either using synchronous messages only or by decoupling the processing within the callback method.

Example for Sending a Synchronous Message (发送同步消息)

import org.snmp4j.*;
...
Snmp snmp = new Snmp(new DefaultUdpTransportMapping());
...
ResponseEvent response = snmp.send(requestPDU, target);
if (response.getResponse() == null) {
// request timed out
...
}
else {
System.out.println("Received response from: "+
response.getPeerAddress());
// dump response PDU
System.out.println(response.getResponse().toString());
}

Example for Sending an Asynchronous Message (发送异步消息)

import org.snmp4j.*;
import org.snmp4j.event.*;
...
Snmp snmp = new Snmp(new DefaultUdpTransportMapping());
...
ResponseListener listener = new ResponseListener() {
public void onResponse(ResponseEvent event) {
PDU response = event.getResponse();
PDU request = event.getRequest();
if (response == null) {
System.out.println("Request "+request+" timed out");
}
else {
System.out.println("Received response "+response+" on request "+
request);
}
};
snmp.sendPDU(request, target, null, listener);
...

Receiving SNMP messages(接收SNMP信息)

SNMP4J receives SNMP messages through the listen port of transport mappings. In order to be able to receive responses or requests, that port needs to be set into listen mode. This has to be done by calling the listen() method of the TransportMapping instance to start the transport mappings internal listen thread. The internal thread is stopped and the listen port is closed by calling the close() method on the TransportMapping instance or the associated Snmp instance.

The transport mapping just receives the SNMP mesage as a stream of bytes and forwards the message to associated MessageDispatcher instances. By default, SNMP4J uses one instance of the MessageDispatcherImpl class for decoding and dispatching incoming messages. That instance is created and used internally by the Snmp class.

The Snmp class processes responses to outstanding requests and forwards PDUs of other SNMP messages to registered CommandResponder listener instances. To receive SNMP messages it is thus sufficient to

1. Create a TransportMapping and initialize its listen port by calling TransportMapping.listen().
2. Create a Snmp instance with the above TransportMapping.
3. Instantiate a class that implements the CommandResponder interface and register it with the Snmp instance by calling Snmp.addCommandResponder(CommandResponder).

When a unhandled SNMP message (thus a SNMP message where no corresponding outstanding request exists) is received, then the processPdu(CommandResponderEvent) method of the CommandResponder will be called with the decoded PDU and additional information about the received SNMP message provided by the message processing model that has decoded the SNMP message.

Example for Receiving SNMP Messages (接收SNMP消息的例子)

import org.snmp4j.*;
import org.snmp4j.smi.*;
import org.snmp4j.mp.SnmpConstants;
...
TransportMapping transport =
new DefaultUdpTransportMapping(new UdpAddress("0.0.0.0/161"));
Snmp snmp = new Snmp(transport);
if (version == SnmpConstants.version3) {
byte[] localEngineID =
((MPv3)snmp.getMessageProcessingModel(MessageProcessingModel.MPv3)).createLocalEngineID();
USM usm = new USM(SecurityProtocols.getInstance(),
new OctetString(localEngineID), 0);
SecurityModels.getInstance().addSecurityModel(usm);
snmp.setLocalEngine(localEngineID, 0, 0);
// Add the configured user to the USM
...
}
snmp.addCommandResponder(this);
transport.listen();
...
public synchronized void processPdu(CommandResponderEvent e) {
PDU command = e.getPdu();
if (command != null) {
...
}
}

以下是 org.snmp4j.smi 包下的说明:

Provides classes for the representation of SMIv1/v2 data types (which also includes some basic ASN.1 primitive data types).
The org.snmp4j.smi classes are capable of BER encoding and decoding themself to/from a byte stream. In addition, the SMI data type classes provide convenient functions for manipulating their content. 
The VariantVariable is a special class that can be used in command responder applications to intercept access to a SMI value.
Variable Binding Examples 
import org.snmp4j.smi.*;
...
VariableBinding vb = new VariableBinding(new OID("1.3.6.1.2.1.1.4.0"));
vb.setValue(new OctetString("SNMP4J Text"));
...
vb = new VariableBinding();
vb.setOid(new OID(new int[] { 1,3,6,1,2,1,1,2,0 }));
...
vb = new VariableBinding(vb.getOid(), new IpAddress("255.255.255.255"));
...
vb = new VariableBinding(vb.getOid(), new Gauge32(2^32-1));
int syntax = vb.getSyntax();
if (syntax != SMIConstants.SYNTAX_GAUGE32) {
// never reached
}
else {
long value = ((UnsignedInteger32)vb.getValue()).getValue();
System.out.println(vb.getOid() + " = " + value);
// prints: 1.3.6.1.2.1.1.2.0 = 4294967295
}
...

The following UML class diagram shows the most important classes of the org.snmp4j.smi package and their relationships (relationships to other packages are not shown): 
UML类图

以下是 org.snmp.asn1 包中的说明

Provides classes and interfaces for the mapping between Abstract Syntax Notation One (ASN.1) formatted values and their transfer syntax according to the Basic Encoding Rules (BER).
The org.snmp4j.asn1 classes are capable of serializing of ASN.1 formatted values into a byte stream and deserializing the same from a byte stream. There are three groups of classes/interfaces in this package:

    
The BER class implements the BER serialization and deserialization by providing static methods for encoding/decoding of primitive ASN.1 and Structure of Management Information (SMI) data types.
    
The BERSerializable interface provides a common interface for all objects that are (de)serializable according to the Basic Encoding Rules (BER).
    
The BERInputStream and the BEROutputStream provide optimized implementations for the serialization and deserialization of the InputStream and OutputStream abstract classes. 

 
The following UML class diagram shows the most important classes of the org.snmp4j.asn1 package and their relationships (relationships to other packages are not shown): 
 

以下是 org.snmp4j.mp 包中的说明

Provides classes and interfaces for the SNMP message processing.
The org.snmp4j.mp classes provide services to process SNMP messages. The services provided are defined in the MessageProcessingModel interface and include the following:

    
Prepare data elements from an incoming SNMP message as described in RFC3412 §7.2.
    
Prepare a response message as defined in RFC3412 §7.1.
    
Prepare an outgoing message as defined in RFC3412 §7.1. 

 
This interface is implemented by the message processing model classes for the SNMP versions 1, v2c, and v3: MPv1, MPv2c, and MPv3. 
The MessageDispatcherImpl chooses which message processing model it uses to process an outgoing or incoming SNMP message based on the SNMP version of the message. The SNMP version is either extracted from the message header (incoming message) or from the Target instance associated with the outgoing PDU (ougoing message).
To be able to match requests and responses SNMP uses request IDs. Since request IDs are created by the command generator, the request IDs are unique within such a command generator only. SNMP4J therefore has to abstract from request IDs and uses PduHandle instances instead. 
If a PDU is processed for sending by the SNMP4J MessageDispatcherImpl and the PDU's request ID is set to 0, then a SNMP4J application wide unique ID is generated and set as request ID of the supplied PDU. In any case, the PDU's request ID will be used as transaction ID of the outgoing message. The transaction ID identifies a messages PduHandle. 
If a PDU is received by the SNMP4J MessageDispatcherImpl a unique transaction ID is generated so that command responders as well as the message processing model can match requests and responses. 
The following UML class diagram shows the most important classes of the org.snmp4j.mp package and their relationships (relationships to other packages are not shown): 
 

以下是 org.snmp4j.transport 包中的说明

Provides transport protocol mappings for SNMP.
The org.snmp4j.transport classes are capable of sending and receiving byte messages to and from a network using transport mapping specific transport protocol. All SNMP4J transport mappings have to implement the org.snmp4j.TransportMapping interface. SNMP4J supports two transport mappings for the transport protocols UDP and TCP: 

    
The UDP transport mapping is the default SNMP transport mapping. It is implemented by the DefaultUdpTransportMapping class.
    
The TCP transport mapping is implemented by the DefaultTcpTransportMapping using the java.nio package. 

Additional transport mappings can be easily added. It is sufficient to implement the org.snmp4j.TransportMapping interface and add an instance of that class to the Snmp (or MessageDispatcher) object. To be able to lookup a transport mapping by an Address class via the TransportMappings (as Snmp does for notification listeners), a transport mapping has to be registered in a transport mapping registration file. The default file is transports.properties in the org.snmp4j.transport package. To use a different file, set the system property org.snmp4j.transportMappings. 
Connection-oriented transport mappings like TCP should implement the ConnectionOrientedTransportMapping interface to support MessageLengthDecoder and TransportStateListener.
The following UML class diagram shows the classes of the org.snmp4j.transport package and their relationships (relationships to other packages are not shown): 
 

以下是 org.snmp4j.util 包中的说明

Contains table retrieval utilities and multi-threading support classes as well as miscellaneous utility classes.
The org.snmp4j.util contains the following groups of classes: 

    
Classes for SNMP table retrieval. The class TableUtils can be used to asynchronously retrieve table data effeciently row by row.
    
Classes for support of multi-threaded message dispatching. The class MultiThreadedMessageDispatcher implements the MessageDispatcher interface and uses the MessageDispatcherImpl class to dispatch incoming message using the threads of a ThreadPool. 

The following UML class diagram shows the classes of the org.snmp4j.util package and their relationships (relationships to other packages are not shown):