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的內存大?。籑axPermSize為最大可占用的Perm內存大小。在用戶生產環境上一般將這兩個值設為相同，以減少運行期間系統在內存申請上所花的開銷。
SurvivorRatio：設置Survivor空間和Eden空間的比例

內存溢出的可能性

1. OLD段溢出
這種內存溢出是最常見的情況之一，產生的原因可能是：
1) 設置的內存參數過小(ms/mx, NewSize/MaxNewSize)
2) 程序問題
單個程序持續進行消耗內存的處理，如循環幾千次的字符串處理，對字符串處理應建議使用StringBuffer。此時不會報內存溢出錯，卻會使系統持續垃圾收集，無法處理其它請求，相關問題程序可通過Thread Dump獲?。ㄒ娤到y問題診斷一章）單個程序所申請內存過大，有的程序會申請幾十乃至幾百兆內存，此時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):