1. java 並發信號量和普通鎖的區別

本質上並沒有區別，都是鎖跟鑰匙的關系。
普通鎖，就是只有一把鑰匙的情況。
而信號量就是提供了可設定鑰匙的數量的操作，當它的鑰匙數量為1時，跟普通鎖沒有區別，至少在功能上是這樣的。
原理都是有鑰匙可以做事，沒鑰匙等著，做完事再把鑰匙還回去。唯一的不同就是，鑰匙的數量，從只能是一把，變成可以多把，而多把意味著同一時間可以做事的人變多了，提升性能，隨之就是並行導致的一系列多線程問題了，這就不展開了。

2. java 信號量semaphore;true怎麼理解

號量維護一個許可集，若有必要，會在獲得許可之前阻塞每一個線程：
//從此信號量獲取給定數目的許可，在提供這些許可前一直將線程阻塞。
acquireUninterruptibly(int permits){}
每一個release()添加一個許可，從而可能釋放一個正在阻塞的獲取者。
Semaphore只對可用許可的號碼進行計數，並採取相應的行動。

如何獲得Semaphore對象？
public Semaphore(int permits,boolean fair)
permits:初始化可用的許

3. java中有沒有signal機制

java中提供了signal的機制。在sun.misc包下，屬於非標准包。重要涉及到兩個類：Signal和SignalHandler。其中Signal主要使用了靜態方法Signal.handle(Signal, SignalHandler)，而SignalHandler是一個介面。

提供如下示例代碼：
public static void main(String[] args) throws InterruptedException {
SignalHandler signalHandler = new SignalHandler() {
@Override
public void handle(Signal signal) {
System.out.println("SignalHandler: " + signal);
}
};
// 只有kill -9能夠結束jvm進程，別的信號量只是發送給java進程處理，至於如何響應是程序代碼決定的
Signal.handle(new Signal("HUP"), signalHandler); // kill -1 PID
Signal.handle(new Signal("INT"), signalHandler); // kill -2 PID
// already used by VM or OS: SIGQUIT
// Signal.handle(new Signal("QUIT"), signalHandler); // kill -3 PID
Signal.handle(new Signal("ABRT"), signalHandler); // kill -6 PID
// already used by VM or OS: SIGKILL
// Signal.handle(new Signal("KILL"), signalHandler); // kill -9 PID
Signal.handle(new Signal("ALRM"), signalHandler); // kill -14 PID
Signal.handle(new Signal("TERM"), signalHandler); // kill -15 PID

for (int i = 0; i < 100; i++) {
Thread.sleep(1000);
System.out.println(i);
}
}

4. java的信號量和線程池的區別

線程組：線程組存在的意義，首要原因是安全。java默認創建的線程都是屬於版系統線程組，而同權一個線程組的線程是可以相互修改對方的數據的。但如果在不同的線程組中，那麼就不能「跨線程組」修改數據，可以從一定程度上保證數據安全。 線程池：線程池存在的意義，首要作用是效率。線程的創建和結束都需要耗費一定的系統時間（特別是創建），不停創建和刪除線程會浪費大量的時間。所以，在創建出一條線程並使其在執行完任務後不結束，而是使其進入休眠狀態，在需要用時再喚醒，那麼 就可以節省一定的時間。如果這樣的線程比較多，那麼就可以使用線程池來進行管理。保證效率。 線程組和線程池共有的特點：1,都是管理一定數量的線程2,都可以對線程進行控制---包括休眠，喚醒，結束，創建，中斷（暫停）--但並不一定包含全部這些操作。

5. JAVA new Semaphore(0, true) 中的0該怎麼理解

mSemaphore = new Semaphore(0, ture)
0表示 mSemaphore 初始值為零，可能 mSemaphore 是一個緩存之類的邊界控制，當 mSemaphore 為零則表示緩存裡面為空，當 mSemaphore 不為零表示緩存裡面有值，
每當我對緩存進行插入後則執行 mSemaphore.release()，此時去獲取許可 mSemaphore..acquire();則會通過，表示這時候緩存裡面不為空，可以執行相應業務操作

案例(來自並發編程實戰)：
@ThreadSafe
public class SemaphoreBoundedBuffer<E> {
/**
* availableItem 表示可以從緩存中刪除的元素個數，初始值為零，因為緩存的初始狀態為空
* availableSpace 表示可以插入到緩存的元素個數，它的初始值等於緩存大小
*/
private final Semaphore availableItem, availableSpace;
@GuardedBy("this") private final E[] item;
@GuardedBy("this") private int putPosition = 0, takePosition = 0;

public SemaphoreBoundedBuffer(int capacity) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.availableItem = new Semaphore(0);
this.availableSpace = new Semaphore(capacity);
this.item = (E[]) new Object[capacity];
}
public boolean isEmpty() {
return availableItem.availablePermits() == 0;
}
public boolean isFull() {
return availableSpace.availablePermits() == 0;
}
public void put(E x) throws InterruptedException {
//獲得一個插入許可
availableSpace.acquire();
doInsert(x);
//釋放許可，表示緩存不為空，不為空執行 acquire 將返回通過許可
availableItem.release();
}

public E take() throws InterruptedException {
//從 availableItem 獲得一個許可，如果緩存不為空，這個請求立即成功，否則被阻塞知道緩存不為空
availableItem.acquire();
//刪除緩存中的下一個元素
E item = doExtract();
//返回一個許可信號量到 availableSpace 信號量表示可以多插入一個緩存了
availableSpace.release();
return item;
}

public synchronized void doInsert(E x) {
int i = putPosition;
item[i] = x;
putPosition = (++i == item.length)? 0 : i;
}

public synchronized E doExtract() {
int i = takePosition;
E x = item[i];
item[i] = null;
takePosition = (++i == item.length)? 0 : i;
return x;
}

}

6. 如何在Android JNI編程中實現對信號量的操作

可以。實現JNI原生函數源文件：版 新建com_lucyfyr_HelloWorld.c文件權： #include #define LOG_TAG "HelloWorld" #include /* Native interface, it will be call in java code */ JNIEXPORT jstring JNICALL Java_com_lucyfyr_HelloWorld_printJNI...

7. 如何用java實現信號量

package synchronization;

public class Semaphore {
private int value;

public Semaphore(){
this.value = 0;
}
public Semaphore(int v){
this.value = v;
}

public synchronized void down(){
while(value <= 0 ){
try{
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
value--;
}

public synchronized void up(){
value++;
notify();
}
}

使用的時候Semophore s;
while(true){
s.wait();
//臨界回區答
s.signal();
}

8. 求大神，java信號量是什麼意思。

Java的信號量實際上是一個功能完畢的計數器，對控制一定資源的消費與回收有著很重要的意義，信號量常常用於多線程的代碼中，並能監控有多少數目的線程等待獲取資源，並且通過信號量可以得知可用資源的數目等等，這里總是在強調「數目」二字，但不能指出來有哪些在等待，哪些資源可用。
因此，本人認為，這個信號量類如果能返回數目，還能知道哪些對象在等待，哪些資源可使用，就非常完美了，僅僅拿到這些概括性的數字，對精確控制意義不是很大。目前還沒想到更好的用法。

9. 用信號量機制解決生產者消費者問題

import java.util.concurrent.Semaphore;

class Q { //倉庫
int n; //倉庫中的產品

// Start with consumer semaphore unavailable.
static Semaphore semCon = new Semaphore(0);
static Semaphore semProd = new Semaphore(1);

void get() {
try {
semCon.acquire();
} catch(InterruptedException e) {
System.out.println("InterruptedException caught");
}

System.out.println("Got: " + n);
semProd.release();
}

void put(int n) {
try {
semProd.acquire();
} catch(InterruptedException e) {
System.out.println("InterruptedException caught");
}

this.n = n;
System.out.println("Put: " + n);
semCon.release();
}
}

class Procer implements Runnable { //生產者
Q q;

Procer(Q q) {
this.q = q;
new Thread(this, "Procer").start();
}

public void run() {
for(int i=0; i < 20; i++) q.put(i);
}
}

class Consumer implements Runnable { //消費者
Q q;

Consumer(Q q) {
this.q = q;
new Thread(this, "Consumer").start();
}

public void run() {
for(int i=0; i < 20; i++) q.get();
}
}

class ProdCon { //測試類
public static void main(String args[]) {
Q q = new Q();
new Consumer(q);
new Procer(q);
}
}

}

10. Java 並發庫的Semaphore類是什麼怎麼用法什麼時候用

Semaphore是Java對多進程和多線程中信號量的實現，信號量用於實現資源的互斥訪問。當專然還有屬其他實現方法——管程、消息傳遞等。建議你先學習有關信號量是如何實現並發的，畢竟，信號量是很難駕馭的並發實現機制。