Java线程:新特征-有返回值的线程
 
在Java5之前,线程是没有返回值的,常常为了“有”返回值,破费周折,而且代码很不好写。或者干脆绕过这道坎,走别的路了。
 
现在Java终于有可返回值的任务(也可以叫做线程)了。
 
可返回值的任务必须实现Callable接口,类似的,无返回值的任务必须Runnable接口。
 
执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了。
 
下面是个很简单的例子:
 
import java.util.concurrent.*;

/** 
* Java线程:有返回值的线程 

* @author Administrator 2009-11-5 0:41:50 
*/ 
public class Test { 
        public static void main(String[] args) throws ExecutionException,
InterruptedException { 
                //创建一个线程池 
                ExecutorService pool = Executors.newFixedThreadPool(2); 
                //创建两个有返回值的任务 
                Callable c1 = new MyCallable("A"); 
                Callable c2 = new MyCallable("B"); 
                //执行任务并获取Future对象 
                Future f1 = pool.submit(c1); 
                Future f2 = pool.submit(c2); 
                //从Future对象上获取任务的返回值,并输出到控制台 
                System.out.println(">>>"+f1.get().toString()); 
                System.out.println(">>>"+f2.get().toString()); 
                //关闭线程池 
                pool.shutdown(); 
        } 
}

class MyCallable implements Callable{ 
        private String oid;

MyCallable(String oid) { 
                this.oid = oid; 
        }

@Override 
        public Object call() throws Exception { 
                return oid+"任务返回的内容"; 
        } 
}

 
>>>A任务返回的内容 
>>>B任务返回的内容

Process finished with exit code 0

 
非常的简单,要深入了解还需要看Callable和Future接口的API啊。
Java线程:新特征-锁(上)
 
在Java5中,专门提供了锁对象,利用锁可以方便的实现资源的封锁,用来控制对竞争资源并发访问的控制,这些内容主要集中在java.util.concurrent.locks 包下面,里面有三个重要的接口Condition、Lock、ReadWriteLock。
 
Condition Condition 将 Object 监视器方法(waitnotify 和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意 Lock 实现组合使用,为每个对象提供多个等待
set (wait-set)。
Lock Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
ReadWriteLock ReadWriteLock 维护了一对相关的锁定,一个用于只读操作,另一个用于写入操作。
 
有关锁的介绍,API文档解说很多,看得很烦,还是看个例子再看文档比较容易理解。
 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.locks.Lock; 
import java.util.concurrent.locks.ReentrantLock;

/** 
* Java线程:锁 

* @author leizhimin 2009-11-5 10:57:29 
*/ 
public class Test { 
        public static void main(String[] args) { 
                //创建并发访问的账户 
                MyCount myCount = new MyCount("95599200901215522", 10000); 
                //创建一个锁对象 
                Lock lock = new ReentrantLock(); 
                //创建一个线程池 
                ExecutorService pool = Executors.newCachedThreadPool(); 
                //创建一些并发访问用户,一个信用卡,存的存,取的取,好热闹啊 
                User u1 = new User("张三", myCount, -4000, lock); 
                User u2 = new User("张三他爹", myCount, 6000, lock); 
                User u3 = new User("张三他弟", myCount, -8000, lock); 
                User u4 = new User("张三", myCount, 800, lock); 
                //在线程池中执行各个用户的操作 
                pool.execute(u1); 
                pool.execute(u2); 
                pool.execute(u3); 
                pool.execute(u4); 
                //关闭线程池 
                pool.shutdown(); 
        } 
}

/** 
* 信用卡的用户 
*/ 
class User implements Runnable { 
        private String name;                //用户名 
        private MyCount myCount;        //所要操作的账户 
        private int iocash;                 //操作的金额,当然有正负之分了 
        private Lock myLock;                //执行操作所需的锁对象

User(String name, MyCount myCount, int iocash, Lock myLock) { 
                this.name = name; 
                this.myCount = myCount; 
                this.iocash = iocash; 
                this.myLock = myLock; 
        }

public void run() { 
                //获取锁 
                myLock.lock(); 
                //执行现金业务 
                System.out.println(name + "正在操作" + myCount + "账户,金额为" + iocash + ",当前金额为" +
myCount.getCash()); 
                myCount.setCash(myCount.getCash() + iocash); 
                System.out.println(name + "操作" + myCount + "账户成功,金额为" + iocash + ",当前金额为" +
myCount.getCash()); 
                //释放锁,否则别的线程没有机会执行了 
                myLock.unlock(); 
        } 
}

/** 
* 信用卡账户,可随意透支 
*/ 
class MyCount { 
        private String oid;         //账号 
        private int cash;             //账户余额

MyCount(String oid, int cash) { 
                this.oid = oid; 
                this.cash = cash; 
        }

public String getOid() { 
                return oid; 
        }

public void setOid(String oid) { 
                this.oid = oid; 
        }

public int getCash() { 
                return cash; 
        }

public void setCash(int cash) { 
                this.cash = cash; 
        }

@Override 
        public String toString() { 
                return "MyCount{" + 
                                "oid='" + oid + '\'' + 
                                ", cash=" + cash + 
                                '}'; 
        } 
}

 
张三正在操作MyCount{oid='95599200901215522', cash=10000}账户,金额为-4000,当前金额为10000 
张三操作MyCount{oid='95599200901215522', cash=6000}账户成功,金额为-4000,当前金额为6000 
张三他爹正在操作MyCount{oid='95599200901215522', cash=6000}账户,金额为6000,当前金额为6000 
张三他爹操作MyCount{oid='95599200901215522', cash=12000}账户成功,金额为6000,当前金额为12000 
张三他弟正在操作MyCount{oid='95599200901215522', cash=12000}账户,金额为-8000,当前金额为12000 
张三他弟操作MyCount{oid='95599200901215522', cash=4000}账户成功,金额为-8000,当前金额为4000 
张三正在操作MyCount{oid='95599200901215522', cash=4000}账户,金额为800,当前金额为4000 
张三操作MyCount{oid='95599200901215522', cash=4800}账户成功,金额为800,当前金额为4800

Process finished with exit code 0

 
从上面的输出可以看到,利用锁对象太方便了,比直接在某个不知情的对象上用锁清晰多了。
 
但一定要注意的是,在获取了锁对象后,用完后应该尽快释放锁,以便别的等待该锁的线程有机会去执行。

Java线程:新特征-锁(下)
 
在上文中提到了Lock接口以及对象,使用它,很优雅的控制了竞争资源的安全访问,但是这种锁不区分读写,称这种锁为普通锁。为了提高性能,Java提供了读写锁,在读的地方使用读锁,在写的地方使用写锁,灵活控制,在一定程度上提高了程序的执行效率。
 
Java中读写锁有个接口java.util.concurrent.locks.ReadWriteLock,也有具体的实现ReentrantReadWriteLock,详细的API可以查看JavaAPI文档。
 
下面这个例子是在文例子的基础上,将普通锁改为读写锁,并添加账户余额查询的功能,代码如下:
 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.locks.ReadWriteLock; 
import java.util.concurrent.locks.ReentrantReadWriteLock;

/** 
* Java线程:锁 

* @author leizhimin 2009-11-5 10:57:29 
*/ 
public class Test { 
        public static void main(String[] args) { 
                //创建并发访问的账户 
                MyCount myCount = new MyCount("95599200901215522", 10000); 
                //创建一个锁对象 
                ReadWriteLock lock = new ReentrantReadWriteLock(false); 
                //创建一个线程池 
                ExecutorService pool = Executors.newFixedThreadPool(2); 
                //创建一些并发访问用户,一个信用卡,存的存,取的取,好热闹啊 
                User u1 = new User("张三", myCount, -4000, lock, false); 
                User u2 = new User("张三他爹", myCount, 6000, lock, false); 
                User u3 = new User("张三他弟", myCount, -8000, lock, false); 
                User u4 = new User("张三", myCount, 800, lock, false); 
                User u5 = new User("张三他爹", myCount, 0, lock, true); 
                //在线程池中执行各个用户的操作 
                pool.execute(u1); 
                pool.execute(u2); 
                pool.execute(u3); 
                pool.execute(u4); 
                pool.execute(u5); 
                //关闭线程池 
                pool.shutdown(); 
        } 
}

/** 
* 信用卡的用户 
*/ 
class User implements Runnable { 
        private String name;                //用户名 
        private MyCount myCount;        //所要操作的账户 
        private int iocash;                 //操作的金额,当然有正负之分了 
        private ReadWriteLock myLock;                //执行操作所需的锁对象 
        private boolean ischeck;        //是否查询

User(String name, MyCount myCount, int iocash, ReadWriteLock myLock, boolean ischeck) { 
                this.name = name; 
                this.myCount = myCount; 
                this.iocash = iocash; 
                this.myLock = myLock; 
                this.ischeck = ischeck; 
        }

public void run() { 
                if (ischeck) { 
                        //获取读锁 
                        myLock.readLock().lock(); 
                        System.out.println("读:" + name + "正在查询" + myCount + "账户,当前金额为" +
myCount.getCash()); 
                        //释放读锁 
                        myLock.readLock().unlock(); 
                } else { 
                        //获取写锁 
                        myLock.writeLock().lock(); 
                        //执行现金业务 
                        System.out.println("写:" + name + "正在操作" + myCount + "账户,金额为" +
iocash + ",当前金额为" + myCount.getCash()); 
                        myCount.setCash(myCount.getCash() + iocash); 
                        System.out.println("写:" + name + "操作" + myCount + "账户成功,金额为" +
iocash + ",当前金额为" + myCount.getCash()); 
                        //释放写锁 
                        myLock.writeLock().unlock(); 
                } 
        } 
}

/** 
* 信用卡账户,可随意透支 
*/ 
class MyCount { 
        private String oid;         //账号 
        private int cash;             //账户余额

MyCount(String oid, int cash) { 
                this.oid = oid; 
                this.cash = cash; 
        }

public String getOid() { 
                return oid; 
        }

public void setOid(String oid) { 
                this.oid = oid; 
        }

public int getCash() { 
                return cash; 
        }

public void setCash(int cash) { 
                this.cash = cash; 
        }

@Override 
        public String toString() { 
                return "MyCount{" + 
                                "oid='" + oid + '\'' + 
                                ", cash=" + cash + 
                                '}'; 
        } 
}

 
写:张三正在操作MyCount{oid='95599200901215522', cash=10000}账户,金额为-4000,当前金额为10000 
写:张三操作MyCount{oid='95599200901215522', cash=6000}账户成功,金额为-4000,当前金额为6000 
写:张三他弟正在操作MyCount{oid='95599200901215522', cash=6000}账户,金额为-8000,当前金额为6000 
写:张三他弟操作MyCount{oid='95599200901215522', cash=-2000}账户成功,金额为-8000,当前金额为-2000 
写:张三正在操作MyCount{oid='95599200901215522', cash=-2000}账户,金额为800,当前金额为-2000 
写:张三操作MyCount{oid='95599200901215522', cash=-1200}账户成功,金额为800,当前金额为-1200 
读:张三他爹正在查询MyCount{oid='95599200901215522', cash=-1200}账户,当前金额为-1200 
写:张三他爹正在操作MyCount{oid='95599200901215522', cash=-1200}账户,金额为6000,当前金额为-1200 
写:张三他爹操作MyCount{oid='95599200901215522', cash=4800}账户成功,金额为6000,当前金额为4800

Process finished with exit code 0

 
在实际开发中,最好在能用读写锁的情况下使用读写锁,而不要用普通锁,以求更好的性能。
 

本文出自 “熔 岩” 博客,请务必保留此出处http://lavasoft.blog.51cto.com/62575/222433

(转)JAVA新特征的更多相关文章

  1. Java线程新特征——Java并发库

    一.线程池   Sun在Java5中,对Java线程的类库做了大量的扩展,其中线程池就是Java5的新特征之一,除了线程池之外,还有很多多线程相关的内容,为多线程的编程带来了极大便利.为了编写高效稳定 ...

  2. Java多线程-新特征-阻塞队列ArrayBlockingQueue

    阻塞队列是Java5线程新特征中的内容,Java定义了阻塞队列的接口java.util.concurrent.BlockingQueue,阻塞队列的概念是,一个指定长度的队列,如果队列满了,添加新元素 ...

  3. Java线程:新特征-线程池

    Sun在Java5中,对Java线程的类库做了大量的扩展,其中线程池就是Java5的新特征之一,除了线程池之外,还有很多多线程相关的内容,为多线程的编程带来了极大便利.为了编写高效稳定可靠的多线程程序 ...

  4. Java线程:新特征-有返回值的线程

    http://lavasoft.blog.51cto.com/62575/222082/ Java线程:新特征-有返回值的线程 2009-11-04 17:33:56 标签:返回值 职场 线程 休闲 ...

  5. (转)Java线程:新特征-原子量,障碍器

    Java线程:新特征-原子量   所谓的原子量即操作变量的操作是“原子的”,该操作不可再分,因此是线程安全的.   为何要使用原子变量呢,原因是多个线程对单个变量操作也会引起一些问题.在Java5之前 ...

  6. (转)Java线程:新特征-条件变量

    Java线程:新特征-条件变量   条件变量是Java5线程中很重要的一个概念,顾名思义,条件变量就是表示条件的一种变量.但是必须说明,这里的条件是没有实际含义的,仅仅是个标记而已,并且条件的含义往往 ...

  7. (转)Java线程:新特征-线程池

    Java线程:新特征-线程池   Sun在Java5中,对Java线程的类库做了大量的扩展,其中线程池就是Java5的新特征之一,除了线程池之外,还有很多多线程相关的内容,为多线程的编程带来了极大便利 ...

  8. Java多线程-新特征-阻塞栈LinkedBlockingDeque

    对于阻塞栈,与阻塞队列相似.不同点在于栈是“后入先出”的结构,每次操作的是栈顶,而队列是“先进先出”的结构,每次操作的是队列头. 这里要特别说明一点的是,阻塞栈是Java6的新特征.. Java为阻塞 ...

  9. Java三大特征之继承(二)

    在<Think in java>中有这样一句话:复用代码是Java众多引人注目的功能之一.但要想成为极具革命性的语言,仅仅能够复制代码并对加以改变是不够的,它还必须能够做更多的事情.在这句 ...

随机推荐

  1. debian将默认中文改成英文

    $ sudo export LANG=en_US.UTF-8 $ sudo dpkg-reconfigure locales

  2. 标准IO和重定向

    1.标准输入/输出/错误 当shell启动,它继承三个文件:stdin.stdout.stderr,标准输入通常来自键盘,标准输出和标准错误通常是屏幕.标准输入/输出/错误的文件描述符为0.1.2 2 ...

  3. Java IO学习笔记三

    Java IO学习笔记三 在整个IO包中,实际上就是分为字节流和字符流,但是除了这两个流之外,还存在了一组字节流-字符流的转换类. OutputStreamWriter:是Writer的子类,将输出的 ...

  4. 关于Vue vue-cli安装遇到的一些问题

    先给出能正确安装的步骤: 1.进盘符 2,为啥不用npm,这是国外的东西,有些电脑无法FQ,会导致安装失败,或者下载速度很慢 3 4 5这是其中一步要填的,自己选择需要啥 问题:用npm安装带来的麻烦 ...

  5. 给js动态创建的对象绑定事件

    1.使用原生JS动态为动态创建的对象绑定事件 1-1.创建一个function,用来兼容IE8以下浏览器添加事件 function addEvent(el, type, fn) {  if(el.ad ...

  6. mysql GROUP_CONCAT获取分组的前几名

    比如说要获取班级的前3名,oracle 可以用 over partition by 来做.mysql就可以用GROUP_CONCAT  + GROUP BY + substring_index实现. ...

  7. 使用 FLASH DATABASE 恢复误删除的用户

    场景描述 误 drop 了生产库中的用户 U1 U1 用户下面有 3 张表(T1-T3),表中数据如下所示: SQL> conn u1/u1 Connected. SQL> select ...

  8. html页面多个a标签点击时显示不同的样式

    <!DOCTYPE HTML> <html lang="en-US"> <head> <meta charset="UTF-8& ...

  9. [leetcode-599-Minimum Index Sum of Two Lists]

    Suppose Andy and Doris want to choose a restaurant for dinner, and they both have a list of favorite ...

  10. ListView 介绍

    1. 通过继承Activity实现ListView 1.1 在XML布局文件中实现一个ListView <ListView android:layout_width="wrap_con ...