多线程高新(黑马程序员)

---------------------------------  Java多线程与并发库高级应用  -------------------------------------------
  1.传统线程机制的回顾
  1.多个线程对同一个数据进行操作(加synchronized()),要线程同步，静态方法只有跟字节码关联,类的字节码是万能的，字节码只有一份
  1.线程同步的方法
  public void output(String name){
int len = name.length();
synchronized (Outputer.class)
{
for(int i=0;i<len;i++){
System.out.print(name.charAt(i));
}
System.out.println();
}
}


public  synchronized  void  output2(String name){
int len = name.length();
for(int i=0;i<len;i++){
System.out.print(name.charAt(i));
}
System.out.println();
}
  2.java5线程的新特性：
  1.ExecutorService threadPool = Executors.newFixedThreadPool(3);
  2.private static Lock lock = new ReentrantLock();
  3.private static Condition subThreadCondition = lock.newCondition();
例题：
private static Lock lock = new ReentrantLock();
private static Condition subThreadCondition = lock.newCondition();
private static boolean bBhouldSubThread = false;
public static void main(String [] args)
{
ExecutorService threadPool = Executors.newFixedThreadPool(3);
threadPool.execute(new Runnable(){
public void run()
{
for(int i=0;i<50;i++)
{
lock.lock();
try
{
if(!bBhouldSubThread)
subThreadCondition.await();
for(int j=0;j<100;j++)
{
System.out.println(Thread.currentThread().getName() + ",j=" + j);
}
bBhouldSubThread = false;
subThreadCondition.signal();
}catch(Exception e)
{
}
finally
{
lock.unlock();
}
}
}

});
threadPool.shutdown();
for(int i=0;i<50;i++)
{
lock.lock();
try
{
if(bBhouldSubThread)
subThreadCondition.await();
for(int j=0;j<10;j++)
{
System.out.println(Thread.currentThread().getName() + ",j=" + j);
}
bBhouldSubThread = true;
subThreadCondition.signal();
}catch(Exception e)
{
}
finally
{
lock.unlock();
}
}
}
1.ExecutorService threadPool = Executors.newSingleThreadExecutor(); threadPool 线程池
线程池：创建一些线程，它们的集合称为线程池，当服务器接受到一个客户请求后，就从线程池中取出一个空闲的线程为之服务，服务完后不关闭该线程，而是将该线程还回到线程池中。
2.子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序
源代码：(用java5线程的新特性实现,ReentrantLock,Condition)
/**
* @param args
*/
public static void main(String[] args) {

final Business business = new Business();
new Thread(
new Runnable() {
public void run() {

for(int i=1;i<=50;i++){
business.sub(i);
}

}
}
).start();

for(int i=1;i<=50;i++){
business.main(i);
}

}

static class Business {
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
  private boolean bShouldSub = true;
  public  void sub(int i){
  lock.lock();
  try{
  while(!bShouldSub){
  try {
condition.await();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
  }
for(int j=1;j<=10;j++){
System.out.println("sub thread sequence of " + j + ",loop of " + i);
}
  bShouldSub = false;
  condition.signal();
  }finally{
  lock.unlock();
  }
  }
 
  public  void main(int i){
  lock.lock();
  try{
while(bShouldSub){
  try {
condition.await();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
  }
for(int j=1;j<=100;j++){
System.out.println("main thread sequence of " + j + ",loop of " + i);
}
bShouldSub = true;
condition.signal();
  }finally{
  lock.unlock();
  }
  }

}
2.Semaphore实现信号灯
ExecutorService service = Executors.newCachedThreadPool();
final  Semaphore sp = new Semaphore(3);
  3.同步工具类(CyclicBarrier,用于等待(比如旅游),CountDownLatch(计时器,倒计时),Exchanger(交换器,用于交换,比如买卖品))
  4.可阻塞的队列(ArrayBlockingQueue,final BlockingQueue queue = new ArrayBlockingQueue(3);)
  5.删除集合时会报错，用 Collection users = new CopyOnWriteArrayList();
  Java5中提供了如下一些同步集合类：
  通过看java.util.concurrent包下的介绍可以知道有哪些并发集合
  ConcurrentHashMap
  CopyOnWriteArrayList
  CopyOnWriteArraySet
5.面试题用到的知识点
//队列，可阻塞队列
final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(1);
//信号灯
final Semaphore semaphore = new Semaphore(1);
final SynchronousQueue<String> queue = new SynchronousQueue<String>();
//操作集合的存取时,用CopyOnWriteArrayList,可以获取condition,lock
private CopyOnWriteArrayList keys = new CopyOnWriteArrayList();
 
1. 总之，要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放在同一个类中，这样比较容易实现它们之间的同步互斥和通信
* 面试题需求:设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序
* 根据题目要求，很明显要用到线程同步(synchronized)
* 用到的知识点,同步synchronized()方法, 外部类调用内部类的方法
*  ThreadTest1 tt=new ThreadTest1();
Inc inc= tt.new Inc();
* Thread t=new Thread(inc); //传一个runnable对象inc 进去 

1.内部类特点：1.内部类中不允许定义静态变量2.在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名
3.如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量
4.可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的
condition 阻塞队列  队列:先进先出

blockingQueueTest.java 阻塞队列

成员变量只有创建类的实例才赋值
静态代码块只有在类加载的时候执行，只会执行一次

匿名构造方法有几个构造方法就调用几次

死锁:都堵住了，方法不能执行

内部类可以访问外部类的对象

线程互斥一定是同一个对象

外部类怎样调用类部类的方法

AtomicInteger


任何线程死了，怎样再启动

多态：:“一个接口，多种实现”，就是同一种事物表现出的多种形态。
ReadWriteLock  ReentrantReadWriteLock

Condition

线程的同步，安全，什么时候用线程异步
同步的数据是安全的还是不安全的
concurrent
ExecutorService 线程池

数组就是连续的一段内存,列表不是一段连续的内存
如果线程被多个应用访问,用ConcurrentHashMap

要实现同步(synhronized) 接受的对象(监视器对象必须是同一个,即传入的对象(this))
同步即互斥,进了这里，就不能进那里

Clooections --->synchronizedMap --->map 的线程同步
Collections.synchronizedMap(null)

HashSet 与HashMap 有什么联系
HashSet 内部使用的是hashMap实现 只是用hashMap key,没有value

使用new Runnable 更面向对象 Runnable 表示一个对象，Runnable表示代表任务的那个对象

Test  同步队列

编译器把代码翻译成字节码 编译器优化
String a =new String("a");  a与b不是同一个对象
String b=new String("a");
a="1"+"";
b="1"+""; a与b是同一个对象

只有满足synchronize(this)
这个this代表的对象是同一个是才互斥,否则不互斥
也就是不是线程同步

迭代的过程中不能对集合进行操作
用CopyOnWriterArrayList可以解决迭代过程中不能对集合进行
操作的问题

java5线程并发库里面的CopyOnWriterArrayList


s1知识点

s2知识点