Android中怎么利用同步锁实现多线程，相信很多没有经验的人对此束手无策，为此本文总结了问题出现的原因和解决方法，通过这篇文章希望你能解决这个问题。
成都创新互联是一家集网站建设,青秀企业网站建设,青秀品牌网站建设,网站定制,青秀网站建设报价,网络营销,网络优化,青秀网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。
一、同步机制关键字synchronized
对于Java来说，最常用的同步机制就是synchronized关键字，他是一种基于语言的粗略锁，能够作用于对象、函数、class。每个对象都只有一个锁，谁能够拿到这个锁谁就有访问权限。当synchronized作用于函数时，实际上锁的也是对象，锁定的对象就是该函数所在类的对象。而synchronized作用于class时则是锁的这个Class类，并非具体对象。
public class SynchronizedClass {
public synchronized void syncMethod(){
//代码
}
public void syncThis(){
synchronized (this){
//代码
}
}
public void syncClassMethod(){
synchronized (SynchronizedClass.class){
//代码
}
}
public synchronized static void syncStaticMethod(){
//代码
}
}上面演示了同步方法、同步块、同步class对象、同步静态方法。前2种锁的是对象，而后两种锁的是class对象。对于class对象来说，它的作用是防止多个线程同时访问添加了synchronized锁的代码块，而synchronized作用于引用对象是防止其他线程访问同一个对象中synchronized代码块或者函数。
二、显示锁———-ReentrankLock和Condition
ReentrankLock 和内置锁synchronized相比，实现了相同的语义，但是更具有更高的灵活性。
(1)获得和释放的灵活性。
(2)轮训锁和定时锁。
(3)公平性。
基本操作:
lock(): 获取锁
tryLock(): 尝试获取锁
tryLock(long timeout,TimeUnit unit): 尝试获取锁，如果到了指定的时间还获取不到，那么超时。
unlock(): 释放锁
newCondition(): 获取锁的 Condition
使用ReentrantLock的一般组合是 lock、tryLock、与unLock成对出现，需要注意的是，千万不要忘记调用unlock来释放锁，负责可能引发死锁的问题。ReentrantLock的常用形式如下所示:
public class ReentrantLockDemo {
Lock lock = new ReentrantLock();
public void doSth(){
lock.lock();
try {
//执行某些操作
}finally {
lock.unlock();
}
}
}需要注意的是，lock必须在finally开中释放，否则，如果受保护的代码抛出异常，锁就可能永远得不到释放！！
ReentrantLock类中还有一个重要的函数newCondition(),该函数用户获取Lock()上的一个条件，也就是说Condition与Lock绑定。Condition用于实现线程间的通信，他是为了解决Object.wait(),nofity(),nofityAll() 难以使用的问题。
Condition的方法如下:
await() : 线程等待
await(int time,TimeUnit unit) 线程等待特定的时间，超过的时间则为超时。
signal() 随机唤醒某个等待线程
signal() 唤醒所有等待中的线程
示例代码:
public class MyArrayBlockingQueue{ // 数据数组 private final T[] items; private final Lock lock = new ReentrantLock(); private Condition notFull = lock.newCondition(); private Condition notEmpty = lock.newCondition() ; // 头部索引 private int head; // 尾部索引 private int tail ; // 数据的个数 private int count; public MyArrayBlockingQueue(int maxSize) { items = (T[]) new Object[maxSize]; } public MyArrayBlockingQueue(){ this(10); } public void put(T t){ lock.lock(); try { while(count == getCapacity()){ System.out.println("数据已满，等待"); notFull.await(); } items[tail] =t ; if(++tail ==getCapacity()){ tail = 0; } ++count; notEmpty.signalAll();//唤醒等待数据的线程 } catch (InterruptedException e) { e.printStackTrace(); }finally { lock.unlock(); } } public int getCapacity(){ return items.length ; } public T take(){ lock.lock(); try { while(count ==0){ System.out.println("还没有数据，等待"); //哪个线程调用await()则阻塞哪个线程 notEmpty.await(); } T ret = items[head]; items[head] = null ; if(++head == getCapacity()){ head =0 ; } --count; notFull.signalAll(); return ret ; } catch (InterruptedException e) { e.printStackTrace(); }finally { lock.unlock(); } return null ; } public int size(){ lock.lock(); try { return count; }finally { lock.unlock(); } } public static void main(String[] args){ MyArrayBlockingQueue aQueue = new MyArrayBlockingQueue<>(); aQueue.put(3); aQueue.put(24); for(int i=0;i<5;i++){ System.out.println(aQueue.take()); } System.out.println("结束"); } }
执行结果:
3
24
还没有数据，等待
三、信号量 Semaphore
Semaphore是一个计数信号量，它的本质是一个“共享锁”。信号量维护了一个信号量许可集，线程可以通过调用acquire()来获取信号量的许可。当信号量中有可用的许可时，线程能获取该许可；否则线程必须等待，直到可用的许可为止。线程可以通过release()来释放它所持有的信号量许可。
示例:
public class SemaphoreTest {
public static void main(String[] args){
final ExecutorService executorService = Executors.newFixedThreadPool(3);
final Semaphore semaphore = new Semaphore(3);
List futures = new ArrayList<>();
for (int i = 0; i < 5; i++) {
Future submit = executorService.submit(new Runnable() {
@Override
public void run() {
try {
semaphore.acquire();
System.out.println(" 剩余许可: " + semaphore.availablePermits());
Thread.sleep(3000);
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
futures.add(submit);
}
}
} 看完上述内容，你们掌握Android中怎么利用同步锁实现多线程的方法了吗？如果还想学到更多技能或想了解更多相关内容，欢迎关注创新互联行业资讯频道，感谢各位的阅读！
