关于线程深入的知识（不断完善中）

Java多线程与并发库高级应用

 

一．传统的线程

1.线程创建

a． 首先去看下线程源码：

b． 创建线程的方法：

b1.推荐：更加面向对象

 

b2.

          一个问题：

子类中的方法：面向对象的思想

降低效率，cpu只有一个

抢占带宽的问题。

2.定时器的使用：Timer类和TimerTask类

（为什么用匿名内部类，主要是增加代码的封装性）

炸弹问题：

炸弹问题升级：两秒钟炸一次之后4秒钟炸一次

内部类中不能声明静态变量如下的count

3.线程互斥与同步，通信问题

 

整段代码同步（注意synchronized最好只用一次，否则容易死锁）

此时的锁对象就是output.class（字节码对象和类对象！）

一个问题，子线程循环10次，接着主线程循环100次，接着有回到子线程循环10次，接着再回到主线程循环100次，如此循环50次，写出程序

首先要把子和父的线程设计到一个方法中，体现了对象的高内聚和健壮性

一个输出到文件的技巧

父方法：

子方法：

子类方法调用：

父类方法调用：

4.线程范围内的共享数据ThreadLocal

5.多线程访问共享对象和数据的方式

1.

例如买票系统

2.如果有两个对象呢？

方法一：

 

方法二：

 

 Java5中的线程并发库

等等，必须要在外部类中定义：

5.线程池

a.线程池的定义使用：（三种常用的线程池）

b.定时器使用

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

 

/**

 * 创建一个线程池里有三个线程主要的方法是固定的

 * 线程池（newFixedThreadPool(3)）还有一种是缓存的线程池(Executors.newCachedThreadPool();)

 * 还有一种是只有一个线程的Executors.newSingleThreadExecutor()//如何实现线程死后重新启动

 * Executors.newFixedThreadPool(3)Executors.excute(new Runnable)方法

 *

 * @authorrpq

 *

 */

publicclassThreadPoolTest {

    publicstatic void main(String[] args) {

         // 创建三个线程的线程池

         ExecutorServicethreadPool = Executors.newFixedThreadPool(3);

         // Executors.newCachedThreadPool();

         for (int i = 1; i <= 10; i++){

             finalint task = i;

             threadPool.execute(new Runnable() {

 

                  @Override

                  publicvoid run() {

                      for (int j = 1; j <= 10; j++){

                          System.out.println(Thread.currentThread().getName()

                                   +"is looping of "+ j +"for task of" + task);

                      }

 

                  }

             });

         }

         Executors.newScheduledThreadPool(3).schedule(new Runnable() {

 

             @Override

             publicvoid run() {

                  // TODO Auto-generated method stub

                  System.out.println("boombing!!!");

             }

         },10, TimeUnit.SECONDS);

         // 每隔两秒炸一次

         Executors.newScheduledThreadPool(3).scheduleAtFixedRate(new Runnable() {

 

             @Override

             publicvoid run() {

                  // TODO Auto-generated method stub

                  System.out.println("rpqrpqrpqbigbigyou");

 

             }

         },6, 2, TimeUnit.SECONDS);

         // 关闭线程池

         // threadPool.shutdown();

    }

}

 

6. Callable与Future的应用（很少使用）

import java.util.Random;

import java.util.concurrent.Callable;

importjava.util.concurrent.CompletionService;

import java.util.concurrent.ExecutionException;

importjava.util.concurrent.ExecutorCompletionService;

importjava.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

 

public class CallableAndFuture {

         publicstatic void main(String[] args) {

                  ExecutorServicenewSingleThreadExecutor = Executors

                                   .newSingleThreadExecutor();

 

                  Future<String>future = newSingleThreadExecutor

                                   .submit(newCallable<String>() {

 

                                            @Override

                                            publicString call() throws Exception {

                                                     //TODO Auto-generated method stub

                                                     Thread.sleep(2000);

                                                     return"hello";

                                            }

                                   });

                  System.out.println("等待结果");

                  try{

                          System.out.println(future.get());

                  }catch (InterruptedException e) {

                          //TODO Auto-generated catch block

                          e.printStackTrace();

                  }catch (ExecutionException e) {

                          //TODO Auto-generated catch block

                          e.printStackTrace();

                  }

 

                  ExecutorServicenewFixedThreadPool = Executors.newFixedThreadPool(10);

                  CompletionService<Integer>completionService = new ExecutorCompletionService<Integer>(

                                   newFixedThreadPool);

                  for(int i = 1; i <= 10; i++) {

                          finalint seq=i;

                          completionService.submit(newCallable<Integer>() {

 

                                   @Override

                                   publicInteger call() throws Exception {

                                            Thread.sleep(newRandom().nextInt(5000));

                                            returnseq;

                                   }

                          });

                  }

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

                  {

                          try{

                                   System.out.println(completionService.take().get());

                          }catch (InterruptedException e) {

                                   //TODO Auto-generated catch block

                                   e.printStackTrace();

                          }catch (ExecutionException e) {

                                   //TODO Auto-generated catch block

                                   e.printStackTrace();

                          }

                  }

 

         }

}

7.Lock&Condition实现线程同步通信