张孝祥_Java多线程与并发库高级应用03

05. 线程范围内共享变量的概念与作用

线程范围内共享数据图解：

代码演示：

class ThreadScopeShareData

{

       三个模块共享数据，主线程模块和AB模块

       privatestatic int data = 0;    准备共享的数据

       存放各个线程对应的数据

       private Map<Thread, Integer>threadData = new HashMap<Thread, Integer>();

       publicstatic void main(String[] args)

       {     创建两个线程

for (int i=0;i<2; i++)

{

       new Thread(

new Runnable()

{

       public void run()

       {现在当前线程中修改一下数据,给出修改信息

              data = new Random().nextInt();

              SOP(Thread.currentThread().getName()+将数据改为+data);

              将线程信息和对应数据存储起来

              threadData.put(Thread.currentThread(),data);

              使用两个不同的模块操作这个数据，看结果

              new A().get();

              new B().get();

}

}

).start();

}

}

       staticclass A

       {

       public void get()

       {

              data =threadData.get(Thread.currentThread());

       SOP(A+Thread.currentThread().getName()+拿到的数据+data);

}

}

       staticclass B

       {

       public void get()

       {

              data =threadData.get(Thread.currentThread());

       SOP(B+Thread.currentThread().getName()+拿到的数据+data);

}

}

}

结果并没与实现线程间的数据同步，两个线程使用的是同一个线程的数据。要解决这个问题，可以将每个线程用到的数据与对应的线程号存放到一个map集合中，使用数据时从这个集合中根据线程号获取对应线程的数据。代码实现：上面红色部分

程序中存在的问题：获取的数据与设置的数据不同步

               Thread-1共享数据设置为：-997057737
              Thread-1--A
模块数据：-997057737
              Thread-0共享数据设置为：11858818
              Thread-0--A
模块数据：11858818
              Thread-0--B
模块数据：-997057737
              Thread-1--B
模块数据：-997057737
最好将Runnable中设置数据的方法也写在对应的模块中，与获取数据模块互斥，以保证数据同步

 

06.ThreadLocal类及应用技巧

       多个模块在同一个线程中运行时要共享同一份数据，实现线程范围内的数据共享可以用上一节中所用的方法。

       JDK1.5提供了ThreadLocal类来方便实现线程范围内的数据共享，它的作用就相当于上一节中的Map。

       每个线程调用全局ThreadLocal对象的set方法，就相当于往其内部的map集合中增加一条记录，key就是各自的线程，value就是各自的set方法传进去的值。

       在线程结束时可以调用ThreadLocal.clear()方法用来更快释放内存，也可以不调用，因为线程结束后也可以自动释放相关的ThreadLocal变量。

       一个ThreadLocal对象只能记录一个线程内部的一个共享变量，需要记录多个共享数据，可以创建多个ThreadLocal对象，或者将这些数据进行封装，将封装后的数据对象存入ThreadLocal对象中。

       将数据对象封装成单例，同时提供线程范围内的共享数据的设置和获取方法，提供已经封装好了的线程范围内的对象实例，使用时只需获取实例对象即可实现数据的线程范围内的共享，因为该对象已经是当前线程范围内的对象了。下边给出张老师的优雅代码：

package cn.itheima;
import java.util.Random;
public
classThreadLocalShareDataDemo
{   /**06.ThreadLocal类及应用技巧
     * 将线程范围内共享数据进行封装，封装到一个单独的数据类中，提供设置获取方法
     * 将该类单例化，提供获取实例对象的方法，获取到的实例对象是已经封装好的当前线程范围内的对象
     */
    public
static voidmain(String[] args)
    {
        for (inti=0; i<2; i++)
        {
            newThread(
                   newRunnable()
                   {                     
                       public
voidrun()
                       {
                           intdata =
new Random().nextInt(889);
    System.out.println(Thread.currentThread().getName()+"产生数据："+data);
                           MyDatamyData = MyData.getInstance();
                           myData.setAge(data);
                           myData.setName("Name:"+data);
                           newA().get();
                           newB().get();
                       }
                   }).start();
        }
    }
   
    static
class A
    {   //可以直接使用获取到的线程范围内的对象实例调用相应方法
        Stringname = MyData.getInstance().getName();
        int
age =MyData.getInstance().getAge();
        public
voidget()
        {
            System.out.println(Thread.currentThread().getName()+"--AA name:"+name+"...age:"+age);
        }
    }  
   
    static
class B
    {
        //可以直接使用获取到的线程范围内的对象实例调用相应方法
        Stringname = MyData.getInstance().getName();
        int
age =MyData.getInstance().getAge();
        public
voidget()
        {
            System.out.println(Thread.currentThread().getName()+"--BB name:"+name+"...age:"+age);
        }
    }  
   
    static
classMyData
    {
        privateString
name;
        private
int age;
        publicString getName()
        {
            return
name;
        }
        public
voidsetName(String name)
        {
            this.name =name;
        }
        public
intgetAge()
        {
            return
age;
        }
        public
voidsetAge(int age)
        {
            this.age =age;
        }
        //单例
        privateMyData() {};
        //提供获取实例方法
        public
staticMyData getInstance()
        {
            //从当前线程范围内数据集中获取实例对象
            MyDatainstance = threadLocal.get();
            if(instance==null)
            {
                instance= new MyData();
                threadLocal.set(instance);
            }
            returninstance;
        }
        //将实例对象存入当前线程范围内数据集中
        staticThreadLocal<MyData>
threadLocal = newThreadLocal<MyData>();
    }
}

 

08.java5原子性操作类的应用

       Java5的线程并发库

       java.util.concurrent在并发编程中很常用的实用工具类。

                     |----locks为锁和等待条件提供一个框架的接口和类，

它不同于内置同步和监视器

                     |----atomic类的小工具包，支持在单个变量上解除锁的线程安全编程。

                            可以对基本类型、数组中的基本类型、类中的基本类型等进行操作

                            |----AtomicInteger

构造方法摘要
AtomicInteger()           创建具有初始值 0 的新 AtomicInteger。
AtomicInteger(int initialValue)           创建具有给定初始值的新 AtomicInteger。
方法摘要
int	addAndGet(int delta)           以原子方式将给定值与当前值相加。
boolean	compareAndSet(int expect, int update)           如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
int	decrementAndGet()           以原子方式将当前值减 1。
double	doubleValue()           以 double 形式返回指定的数值。
float	floatValue()           以 float 形式返回指定的数值。
int	get()           获取当前值。
int	getAndAdd(int delta)           以原子方式将给定值与当前值相加。
int	getAndDecrement()           以原子方式将当前值减 1。
int	getAndIncrement()           以原子方式将当前值加 1。
int	getAndSet(int newValue)           以原子方式设置为给定值，并返回旧值。
int	incrementAndGet()           以原子方式将当前值加 1。
int	intValue()           以 int 形式返回指定的数值。
void	lazySet(int newValue)           最后设置为给定值。
long	longValue()           以 long 形式返回指定的数值。
void	set(int newValue)           设置为给定值。
String	toString()           返回当前值的字符串表示形式。
boolean	weakCompareAndSet(int expect, int update)           如果当前值 == 预期值，则以原子方式将该设置为给定的更新值。

                            |----AtomicIntegerArray

构造方法摘要
AtomicIntegerArray (int length)           创建给定长度的新 AtomicIntegerArray。
AtomicIntegerArray (int[] array)           创建与给定数组具有相同长度的新 AtomicIntegerArray，并从给定数组复制其所有元素。
方法摘要
int	addAndGet (int i, int delta)           以原子方式将给定值与索引 i 的元素相加。
boolean	compareAndSet (int i, int expect, int update)           如果当前值 == 预期值，则以原子方式将位置 i 的元素设置为给定的更新值。
int	decrementAndGet (int i)           以原子方式将索引 i 的元素减 1。
int	get (int i)           获取位置 i 的当前值。
int	getAndAdd (int i, int delta)           以原子方式将给定值与索引 i 的元素相加。
int	getAndDecrement (int i)           以原子方式将索引 i 的元素减 1。
int	getAndIncrement (int i)           以原子方式将索引 i 的元素加 1。
int	getAndSet (int i, int newValue)           将位置 i 的元素以原子方式设置为给定值，并返回旧值。
int	incrementAndGet (int i)           以原子方式将索引 i 的元素加 1。
void	lazySet (int i, int newValue)           最后将位置 i 的元素设置为给定值。
int	length ()           返回该数组的长度。
void	set (int i, int newValue)           将位置 i 的元素设置为给定值。
String	toString ()           返回数组当前值的字符串表示形式。
boolean	weakCompareAndSet (int i, int expect, int update)           如果当前值 == 预期值，则以原子方式将位置 i 的元素设置为给定的更新值。

 

09.java5线程并发库的应用

       如果没有线程池，需要在run方法中不停判断，还有没有任务需要执行

       线程池的通俗比喻：接待客户，为每个客户都安排一个工作人员，接待完成后该工作人员就废掉。服务器每收到一个客户请求就为其分配一个线程提供服务，服务结束后销毁线程，不断创建、销毁线程，影响性能。

       线程池：先创建多个线程放在线程池中，当有任务需要执行时，从线程池中找一个空闲线程执行任务，任务完成后，并不销毁线程，而是返回线程池，等待新的任务安排。

       线程池编程中，任务是提交给整个线程池的，并不是提交给某个具体的线程，而是由线程池从中挑选一个空闲线程来运行任务。一个线程同时只能执行一个任务，可以同时向一个线程池提交多个任务。

线程池创建方法：

a、创建一个拥有固定线程数的线程池

       ExecutorServicethreadPool = Executors.newFixedThreadPool(3);  


       b、创建一个缓存线程池 
线程池中的线程数根据任务多少自动增删动态变化

       ExecutorServicethreadPool = Executors.newCacheThreadPool();

       c、创建一个只有一个线程的线程池 
与单线程一样  但好处是保证池子里有一个线程，

当线程意外死亡，会自动产生一个替补线程，始终有一个线程存活

       ExecutorServicethreadPool = Executors.newSingleThreadExector();     


往线程池中添加任务

       threadPool.executor(Runnable)

关闭线程池：

       threadPool.shutdown() 线程全部空闲，没有任务就关闭线程池

       threadPool.shutdownNow() 不管任务有没有做完，都关掉

 

用线程池启动定时器：

       a、创建调度线程池，提交任务        延迟指定时间后执行任务

       Executors.newScheduledThreadPool(线程数).schedule(Runnable, 延迟时间，时间单位);

       b、创建调度线程池，提交任务， 延迟指定时间执行任务后，间隔指定时间循环执行

       Executors.newScheduledThreadPool(线程数). scheduleAtFixedRate (Runnable,延迟时间，

间隔时间，时间单位);

       所有的 schedule 方法都接受相对延迟和周期作为参数，而不是绝对的时间或日期。将以

Date

所表示的绝对时间转换成要求的形式很容易。例如，要安排在某个以后的
Date 运行，可以使用：schedule(task,date.getTime() - System.currentTimeMillis(),TimeUnit.MILLISECONDS)。

 

10.Callable与Future的应用：获取一个线程的运行结果

public interface Callable<V>

返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做call 的方法。 Callable 接口类似于
Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是Runnable 不会返回结果，并且无法抛出经过检查的异常。

只有一个方法V

call

()

计算结果，如果无法计算结果，则抛出一个Exception异常。

使用方法：

       ExecutorServicethreadPool = Executors.newSingleThreadExccutor();

       如果不需要返回结果，就用execute方法 调用submit方法返回一个Future对象

       Future<T> future = threadPool.submit(new Callable<T>(){//接收一个Callable接口的实例对象

                     覆盖Callable接口中的call方法，抛出异常

                     publicTcall() throws Exception

                     {

                            ruturnT

}

});

获取Future接收的结果

future.get（）；会抛出异常

future.get（）没有拿到结果就会一直等待

       Future取得的结果类型和Callable返回的结果类型必须一致，通过泛型实现。Callable要通过ExecutorService的submit方法提交，返回的Future对象可以取消任务。

 

public interface Future<V>

Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由cancel 方法来执行。还提供了其他方法，以确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算。如果为了可取消性而使用Future 但又不提供可用的结果，则可以声明Future<?> 形式类型、并返回 null 作为底层任务的结果。

方法摘要
boolean	cancel(boolean mayInterruptIfRunning)           试图取消对此任务的执行。
V	get()           如有必要，等待计算完成，然后获取其结果。
V	get(long timeout, TimeUnit unit)           如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。
boolean	isCancelled()           如果在任务正常完成前将其取消，则返回 true。
boolean	isDone()           如果任务已完成，则返回 true。

 

public interface CompletionService<V>

       CompletionService用于提交一组Callable任务，其take方法返回一个已完成的Callable任务对应的Future对象。好比同时种几块麦子等待收割，收割时哪块先熟先收哪块。

将生产新的异步任务与使用已完成任务的结果分离开来的服务。生产者submit 执行的任务。使用者 take 已完成的任务，并按照完成这些任务的顺序处理它们的结果。例如，CompletionService 可以用来管理异步 IO ，执行读操作的任务作为程序或系统的一部分提交，然后，当完成读操作时，会在程序的不同部分执行其他操作，执行操作的顺序可能与所请求的顺序不同。

通常，CompletionService 依赖于一个单独的
Executor 来实际执行任务，在这种情况下，CompletionService 只管理一个内部完成队列。ExecutorCompletionService 类提供了此方法的一个实现。

CompletionService方法摘要
Future<V>	poll()           获取并移除表示下一个已完成任务的 Future，如果不存在这样的任务，则返回 null。
Future<V>	poll(long timeout, TimeUnit unit)          获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则将等待指定的时间（如果有必要）。
Future<V>	submit(Callable<V> task)           提交要执行的值返回任务，并返回表示挂起的任务结果的 Future。
Future<V>	submit(Runnable task, V result)           提交要执行的 Runnable 任务，并返回一个表示任务完成的 Future，可以提取或轮询此任务。
Future<V>	take()           获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则等待。
ExecutorCompletionService构造方法摘要
ExecutorCompletionService(Executor executor)           使用为执行基本任务而提供的执行程序创建一个 ExecutorCompletionService，并将 LinkedBlockingQueue 作为完成队列。
ExecutorCompletionService(Executor executor, BlockingQueue<Future<V>> completionQueue)           使用为执行基本任务而提供的执行程序创建一个 ExecutorCompletionService，并将所提供的队列作为其完成队列。

示例：

ExecutorService threadPool = Executors.newFixedThreadPool(10);      //创建线程池，传递给coms

       用threadPool执行任务，执行的任务返回结果都是整数

CompletionService<Integer> coms = newExecutorCompletionService<Integer>(threadPool);

       提交10个任务  种麦子

for (int i=0; i<10; i++)

{

       finalint num = i+1;

coms.submit(newCallable<Integer>(){

public Integercall()      覆盖call方法

{匿名内部类使用外部变量要用final修饰

       SOP(任务+num);

       Thread.sleep(newRandom().nextInt(6)*1000);

       return num;

}

});

}

       等待收获       割麦子

for (int i=0; i<10; i++)

{     take获取第一个Future对象，用get获取结果

       SOP(coms.take().get());

}