一、JAVA多线程之Lock
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * Lock锁用来进行事务性操作时需要将共享资源锁定,保证事务性操作时只有一个线程能对资源进行操作。 * 可跨越多个方法进行同步, 等同于Synchronized关键字,但synchronized仅仅能够对方法或者代码 * 块进行同步。 * ReentrantLock 将由最近成功获得锁,并且还没有释放该锁的线程所拥有. * ReadWriteLock内置两个Lock,一个是读的Lock,一个是写的Lock。 多个线程可同时得到读的Lock, * 但只有一个线程能得到写的Lock。 */ public class LockerTest { /** * 测试ReadLock的使用。在方法中使用Lock,可以避免使用Synchronized关键字。 */ public static class ReadLockTest { // ReentrantLock 将由最近成功获得锁,并且还没有释放该锁的线程所拥有。 // 当锁没有被另一个线程所拥有时,调用 lock 的线程将成功获取该锁并返回 Lock lock = new ReentrantLock();// 锁 double value = 0d; // 值 int addtimes = 0; /** * 同步方法,为value累加值v,由于加了锁lock,每个线程执行该方法时都会等待顺序执行, * 等待前一线程锁释放后再执行该方法。 */ public void addValue(double v) { lock.lock();// 取得锁 System.out.println("ReadLockTest to addValue: " + v + " addTimes:"+addtimes +" Times:" + System.currentTimeMillis()); try { Thread.sleep(1000); } catch (InterruptedException e) { } this.value += v; this.addtimes++; lock.unlock();// 释放锁 } public double getValue() { return this.value; } } /** * 测试ReadLockTest应用 * @throws Exception */ public static void testReadLockTest() throws Exception{ final ReadLockTest lockTest = new ReadLockTest(); // 新建任务1,调用ReadLockTest的addValue方法 Runnable task1 = new Runnable(){ public void run(){ lockTest.addValue(55.55); } }; // 新建任务2,调用lockTest的getValue方法 Runnable task2 = new Runnable(){ public void run(){ System.out.println("value: " + lockTest.getValue()); } }; // 创建线程池,新建任务执行服务 ExecutorService cachedService = Executors.newCachedThreadPool(); // Future 表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并获取计算的结果 Future future = null; // 同时执行任务1三次,由于addValue方法使用了锁机制,所以,实质上会顺序执行 for (int i=0; i<3; i++){ // 提交一个 Runnable任务用于执行,并返回一个表示该任务的 Future future = cachedService.submit(task1); } // 等待最后一个任务1被执行完,然后获取其结果 future.get(); // 再执行任务2,输出结果 future = cachedService.submit(task2); // 等待任务2执行完后,关闭任务执行服务 future.get(); // shutdown() 方法在终止前允许执行以前提交的任务 cachedService.shutdownNow(); } //////////////////////////////////////////////////////////////////////// /** * ReadWriteLock内置两个Lock,一个是读的Lock,一个是写的Lock。 * 多个线程可同时得到读的Lock,但只有一个线程能得到写的Lock, * 而且写的Lock被锁定后,任何线程都不能得到Lock。ReadWriteLock提供的方法有: * readLock(): 返回一个读的lock * writeLock(): 返回一个写的lock, 此lock是排他的。 * ReadWriteLockTest很适合处理类似文件的读写操作。 * 读的时候可以同时读,但不能写;写的时候既不能同时写也不能读。 */ public static class ReadWriteLockTest{ //ReadWriteLock 维护了一对相关的锁,一个用于只读操作,另一个用于写入操作。 // 只要没有 writer,读取锁可以由多个 reader 线程同时保持。写入锁是独占的。 ReadWriteLock lock = new ReentrantReadWriteLock(); // 值 double value = 0d; int addtimes = 0; /** * 增加value的值,不允许多个线程同时进入该方法 */ public void addValue(double v) { // 得到writeLock并锁定 Lock writeLock = lock.writeLock(); writeLock.lock(); System.out.println("ReadWriteLockTest to addValue: " + v + " addtimes:" + addtimes + " Times:"+System.currentTimeMillis()); try { Thread.sleep(1000); } catch (InterruptedException e) { } try { // 做写的工作 this.value += v; this.addtimes++; } finally { // 释放writeLock锁 writeLock.unlock(); } } /** * 获得信息。当有线程在调用addValue方法时,getInfo得到的信息可能是不正确的。 * 所以,也必须保证该方法在被调用时,没有方法在调用addValue方法。 */ public String getInfo() { // 得到readLock并锁定(读锁可同时获取进行访问) Lock readLock = lock.readLock(); readLock.lock(); System.out.println("ReadWriteLockTest to getInfo " + System.currentTimeMillis()); try { Thread.sleep(1000); } catch (InterruptedException e) { } try { // 做读的工作 return this.value + " : " + this.addtimes; } finally { // 释放readLock readLock.unlock(); } } } public static void testReadWriteLockTest() throws Exception{ final ReadWriteLockTest readWriteLockTest = new ReadWriteLockTest(); // 新建任务1,调用lockTest的addValue方法 Runnable task_1 = new Runnable(){ public void run(){ readWriteLockTest.addValue(55.55); } }; // 新建任务2,调用lockTest的getValue方法 Runnable task_2 = new Runnable(){ public void run(){ System.out.println("info: " + readWriteLockTest.getInfo()); } }; // 新建任务执行服务 ExecutorService cachedService_1 = Executors.newCachedThreadPool(); Future future_1 = null; // 同时执行5个任务,其中前2个任务是task_1,后两个任务是task_2 for (int i=0; i<2; i++){ future_1 = cachedService_1.submit(task_1); } for (int i=0; i<2; i++){ future_1 = cachedService_1.submit(task_2); } // 最后一个任务是task_1 future_1 = cachedService_1.submit(task_1); // 这5个任务的执行顺序应该是: // 第一个task_1先执行,第二个task_1再执行;这是因为不能同时写,所以必须等。 // 然后2个task_2同时执行;这是因为在写的时候,就不能读,所以都等待写结束, // 又因为可以同时读,所以它们同时执行 // 最后一个task_1再执行。这是因为在读的时候,也不能写,所以必须等待读结束后,才能写。 // 等待最后一个task_2被执行完 future_1.get(); cachedService_1.shutdownNow(); } public static void main(String[] args) throws Exception{ // 测试ReentrantLock LockerTest.testReadLockTest(); System.out.println("---------------------"); // 测试ReentrantReadWriteLock LockerTest.testReadWriteLockTest(); } }
二、JAVA多线程之Condition
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * Condition 将 Object 监视器方法(wait、notify 和 notifyAll)分解成截然不同的对象, * 以便通过将这些对象与任意 Lock 实现组合使用,为每个对象提供多个等待 set(wait-set)。 * 其中,Lock 替代了 synchronized 方法和语句的使用, * Condition 替代了 Object 监视器方法的使用。 */ public class ConditionTest{ private Lock lock = new ReentrantLock(); //Condition实例实质上被绑定到一个锁上。通过newCondition()方法获得Condition实例 private Condition conditionA = lock.newCondition(); private Condition conditionB = lock.newCondition(); private Condition conditionC = lock.newCondition(); private String type = "A"; public void A(){ lock.lock(); try{ while (type != "A") { try{ // conditionA在接到信号或被中断之前一直处于等待状态。 conditionA.await(); } catch (InterruptedException e){ e.printStackTrace(); } } System.out.println(Thread.currentThread().getName() + " 正在打印A"); type = "B"; // 唤醒等待线程 conditionB.signal(); } finally{ lock.unlock(); } } public void B(){ lock.lock(); try{ while (type != "B"){ try{ conditionB.await(); } catch (InterruptedException e){ e.printStackTrace(); } } System.out.println(Thread.currentThread().getName() + " 正在打印B"); type = "C"; conditionC.signal(); } finally{ lock.unlock(); } } public void C(){ lock.lock(); try{ while (type != "C"){ try{ conditionC.await(); } catch (InterruptedException e){ e.printStackTrace(); } } System.out.println(Thread.currentThread().getName() + " 正在打印C"); type = "A"; conditionA.signal(); } finally{ lock.unlock(); } } public static void main(String args[]){ ConditionTest test = new ConditionTest(); // 三个线程依次打印ABC test.A(); //test.B(); test.C(); } }
三、 Java多线程之Semaphore
import java.util.ArrayList; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * Java 5.0里新加了4个协调线程间进程的同步装置,它们分别是: * Semaphore, CountDownLatch, CyclicBarrier和Exchanger. * 本例主要介绍Semaphore。 * Semaphore是用来管理一个资源池的工具,可以看成是个通行证, * 线程要想从资源池拿到资源必须先拿到通行证, * 如果线程暂时拿不到通行证,线程就会被阻断进入等待状态。 */ public class SemaphoreTest { /** * 模拟资源池的类 * 只为池发放2个通行证,即同时只允许2个线程获得池中的资源。 */ public static class Pool { // 保存资源池中的资源 ArrayList<String> poolList = null; // 通行证 Semaphore pass = null; Lock lock = new ReentrantLock(); public Pool(int size) { // 初始化资源池 poolList = new ArrayList<String>(); for (int i = 0; i < size; i++) { poolList.add("Resource " + i); } // 发放2个通行证 pass = new Semaphore(2); } /** * 获取通行证,并获取资源 */ public String get() throws InterruptedException { System.out.println("Try to get a pass..."); // 获取通行证,只有得到通行证后才能得到资源,在得到通行证之前线程将一直被阻塞 pass.acquire(); System.out.println("Got a pass"); return getResource(); } /** * 归还通行证,并归还资源 */ public void put(String resource) { // 归还通行证,并归还资源 System.out.println("Released a pass"); pass.release(); releaseResource(resource); } /** * 获取资源 */ private String getResource() { lock.lock(); String result = poolList.remove(0); System.out.println("资源 " + result + " 被取走"); lock.unlock(); return result; } /** * 归还资源 */ private void releaseResource(String resource) { lock.lock(); System.out.println("资源 " + resource + " 被归还"); poolList.add(resource); lock.unlock(); } } public static void testPool() { // 准备10个资源的资源池,由于只有两个通行证,同时只允许2个线程获得池中的资源 final Pool aPool = new Pool(10); Runnable worker = new Runnable() { public void run() { String resource = null; try { //取得resource,前提是取得通行证 resource = aPool.get(); //用resource做工作 System.out.println("I am working on " + resource); Thread.sleep(500); System.out.println("I finished on " + resource); } catch (InterruptedException ex) { } //归还resource,同时归还通行证 aPool.put(resource); } }; // 启动5个任务 ExecutorService service = Executors.newCachedThreadPool(); for (int i = 0; i < 5; i++) { service.submit(worker); } service.shutdown(); } public static void main(String[] args) { SemaphoreTest.testPool(); } }
四、 JAVA多线程之Callable
import java.util.concurrent.Callable; /** * Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其它 * 线程执行的任务。Callable和Runnable有几点不同: * Callable规定的方法是call(),而Runnable规定的方法是run(). * Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。 * call()方法可抛出异常,而run()方法是不能抛出异常的。 * 运行Callable任务可拿到一个Future对象,通过Future对象可了解任务执行情况,可取消任务的执行, * 还可获取任务执行的结果。 */ public class DoCallStuff implements Callable { private int aInt; public DoCallStuff(int aInt) { this.aInt = aInt; } public String call() throws Exception { boolean resultOk = false; if (aInt == 0) { resultOk = true; } else if (aInt == 1) { while (true) { System.out.println("looping...."); Thread.sleep(3000); } } else { throw new Exception("Callable terminated with Exception!"); } if (resultOk) { return "Task done."; } else { return "Task failed"; } } }
五、JAVA多线程之CopyOnWriteArrayList
import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.concurrent.CopyOnWriteArrayList; /** * *同步集合类:ConcurrentHashMap,CopyOnWriteArrayList,CopyOnWriteArraySet等 * *CopyOnWriteArrayList在进行数据修改时,都不会对数据进行锁定,每次修改时,先拷贝整个数组, *然后修改其中的一些元素,完成上述操作后,替换整个数组的指针。对CopyOnWriteArrayList进行读取时, *也不进行数据锁定,直接返回需要查询的数据,如果需要返回整个数组,那么会将整个数组拷贝一份,再返回, *保证内部array在任何情况下都是只读的。 *如果需要频繁对CopyOnWriteArrayList进行修改,而很少读取的话,那么会严重降低系统性能。 *因为没有锁的干预,所以CopyOnWriteArrayLIst在少量修改,频繁读取的场景下,有很好的并发性能。 * */ public class CopyOnWriteArrayListTest { /** * 集合的线程并发问题 */ public void test1(){ Collection<User> list = new ArrayList<User>(); list.add(new User("张三",28)); list.add(new User("李四",38)); list.add(new User("王五",29)); Iterator<User> itrUser = list.iterator(); while(itrUser.hasNext()){ User user = itrUser.next(); if("王五".equals(user.getName())){ list.remove(user); }else{ System.out.println(user.getName()+" "+user.getAge()); } } } /** * 集合的线程并发问题改进,采用同步集合类 */ public void test2(){ Collection<User> list = new CopyOnWriteArrayList<User>(); list.add(new User("张三",28)); list.add(new User("李四",38)); list.add(new User("王五",29)); Iterator<User> itrUser = list.iterator(); while(itrUser.hasNext()){ User user = itrUser.next(); if("王五".equals(user.getName())){ list.remove(user); }else{ System.out.println(user.getName()+" "+user.getAge()); } } } /** * @param args */ public static void main(String[] args) { CopyOnWriteArrayListTest listTest = new CopyOnWriteArrayListTest(); // 普通集合类,产生线程并发问题,抛出异常 //listTest.test1(); // 同步集合类,线程安全,不抛出异常 listTest.test2(); } }
相关推荐
Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式...
Java多线程读大文件 java多线程写文件:多线程往队列中写入数据
java多线程PPT 多线程基本概念 创建线程的方式 线程的挂起与唤醒 多线程问题
一个java 多线程操作数据库应用程序!!!
详细的讲解了java多线程的原理,并配有代码进行实战,适合java初学者和想对多线程有进一步了解的人。
java多线程经典案例,线程同步、线程通信、线程阻塞等经典案例
多线程启动.java多线程启动.java多线程启动.java多线程启动.java
该文档总结了Java多线程相关的知识点,分享给大家,简单易懂!
java多线程处理数据库数据,使用并发包,无框架,可批量处数据库数据,进行增删改。。等等操作。
java多线程并发查询数据库,使用线程池控制分页,并发查询。
《Java多线程编程核心技术》建议猿友们读两遍,因为其写得没有那么抽象,第一遍有些概念不是很理解,可以先跳过并记录起来,第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味,并贯穿全部是指点来思考,并将...
他是一个多线程应用的例。多初学者来说是个不错的选择
java多线程实现大批量数据切分成指定份数的数据,然后多线程处理入库或者导出,线程的个数和每份数据的数量都可以控制
资深Java专家10年经验总结,全程案例式讲解,首本全面介绍Java多线程编程技术的专著 结合大量实例,全面讲解Java多线程编程中的并发访问、线程间通信、锁等最难突破的核心技术与应用实践 Java多线程无处不在,如...
JAVA多线程端点续传下载JAVA多线程端点续传下载JAVA多线程端点续传下载JAVA多线程端点续传下载JAVA多线程端点续传下载JAVA多线程端点续传下载JAVA多线程端点续传下载JAVA多线程端点续传下载JAVA多线程端点续传下载...
java多线程处理大数据,可根据配置的线程数,任务去调度处理
java多线程,对多线程,线程池进行封装,方便使用
java 多线程 其实就是每个线程都拥有自己的内存空间,多线程之间的通信,比例A线程修改了主内存(main方法的线程)变量,需要把A线程修改的结果同步到主线程中,这时B线程再从主线程获取该变量的值,这样就实现了...
java多线程模拟队列实现排队叫号,多线程模拟排队叫号取号 java多线程模拟队列实现排队叫号,多线程模拟排队叫号取号
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化,即在一块芯片上集成多个处理器内核(Core),多核处理器(Multicore Processor)离我们越来越近了――如今...