public class Test{
	//4创建子类对象
    public static void main(String[] args){
    	     MyThread mt=new MyThread();
        //5启动线程
        mt.start();
        //主线程
        for(int i=0;i<1000;i++){
            System.out.println(5678);
        }
    }
}
//1自定义类继承Thread类
public class MyThread extends Thread{
    //2重写run()方法
	public void run(){
      //3实现方法
    	    for(int i=0;i<1000;i++){  System.out.println(1234);
      }    
    }    
}

public class Test{
    public static void main(String[] args){
        //1继承Thread类并创建对象
    	    new Thread(){
          //重写run()方法
           public void run(){
             //实现run()方法
              for(){
               System.out.println(1234);
             }    
          }
        }.start();
        //主线程
        for(int i=0;i<1000;i++){
           System.out.println(5678);
        }
    }
}

public class Test{
    public static void main(String[] args){
        //4创建Runnabkle子类对象
        Mythread my=new Mythread();
        //5将Runnable子类对象作为参数传入Thread构造方法中，创建Thread对象
    	Thread mt=new Thread(my);
        //6启动线程
        mt.start();
        //主线程
        for(int i=0;i<1000;i++){
            System.out.println(5678);
        }
    }
}
//1自定义类实现Runnable接口
public class MyThread implements Runnable{
    //2重写run()方法
	public void run(){
        //3实现方法
    	for(int i=0;i<1000;i++){
            System.out.println(1234);
        }    
    }    
}

public class Test{
    public static void main(String[] args){
        Thread th=new Thread(new Runnable(){
        	public void run(){
            	for(int i=0;i<1000;i++){
                    System.out.println(1234);
                }     
            }
        });
        /*
        new Thread(new Runnable(){
                public void run(){
                    for(int i=0;i<1000;i++){
                        System.out.println(1234);
                    }     
                }
            }
        ).start();
        /*
    	th.start();
        //主线程
        for(int i=0;i<1000;i++){
            System.out.println(5678);
        }
    }
}

public class Test{
	public static void main(String[] arge){
        //线程1
        //这里加final修饰：因为匿名内类在调用方法的局部变量时，局部变量必须加final修饰。
       final Thread t1=new Thread(){
        	public void run(){
            	for(int i=0;i<100;i++){
                	System.out.println("aaa");
                }
            } 
        };
        //线程2
        Thread t1=new Thread(){
        	public void run(){
            	for(int i=0;i<100;i++){
                    //线程2执行后，线程1加入
                    t1.join();
                	System.out.println("bbb");
                }
            } 
        };
        t2.start();
        t1.start();
    }
}

public class DepthLock{
	private static String s1="左"；
    private static String s2="右"；
    public static void main(String[] args){
        //线程1
    	new Thread(){
        	public void run(){
            	while(true){
                	synchronized(s1){
                        //解释一下：当前第一个线程拿到了s1对象，然后往下执行
                    	System.out.println(this.getName()+s1);
                        //当执行完打印的时候，这个时候如果线程2还没有拿到s2的话，则会继续向下进行，直到打印完
                        //然后释放掉s1；但是如果此时恰好线程2抢到执行权，拿到了S2,则会发生死锁，因为线程2还没有释放
                        //s2,所以线程1拿不到s2,然后，线程1执行不下去，也就没法释放s1,线程2如果想释放s2,就得先拿到s1,
                        //则陷入死锁状态
                        synchronized(s2){
                        	System.out.println(this.getName()+s2);
                        }
                    }
                }
            }
        }.start();
        //线程2
        new Thread(){
        	public void run(){
            	while(true){
                	synchronized(s2){
                    	System.out.println(this.getName()+s2);
                        synchronized(s1){
                        	System.out.println(this.getName()+s1);
                        }
                    }
                }
            }
        }.start();
    }
}

public class Demo_notify {
	/**
	 * 两线程之间通讯
	 */
	public static void main(String[] args) {
		final Demo d=new Demo();
		//线程1
		new Thread(){
			public void run(){
                //一定要在循环里执行
				while(true){
					try {
						d.show1();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}.start();
		//线程二:
		new Thread(){
			public void run(){
				while(true){
					try {
						d.show2();
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
				}
			}
		}.start();
	}

}
//两线程交替进行
class Demo{
	private  int flag=1;
	public void show1() throws InterruptedException{
		synchronized (this) {
            //过程解释：两个线程都开启，然后假设线程1，抢到了执行权，则拿到了锁对象，此时线程2，得不到锁，无法打印
            //然后打印“赵钱孙李”，然后flag为2
            //执行唤醒，此时两个线程都是醒着的，然后，循环进行，然后线程1变为等待状态，然后释放了锁对象。
            //线程2就拿到了锁对象，然后打印“周吴郑王”，然后flag变为1，然后执行了对象的notify()，此时线程1被唤醒
            //这个时候也就是都醒着，然后循环继续，flag不为2，线程2变为等待状态，然后释放锁对象，线程1再继续。
			if (flag!=1) {
				//线程等待
				this.wait();
			}
			System.out.print("赵");
			System.out.print("钱");
			System.out.print("孙");
			System.out.print("李");
			System.out.print("\r\n");
			flag=2;
			this.notify();
		}
	}
	public void show2() throws InterruptedException{
		synchronized (this) {
			if (flag!=2) {
				this.wait();
			}
			System.out.print("周");
			System.out.print("吴");
			System.out.print("郑");
			System.out.print("王");
			System.out.print("\r\n");
			flag=1;
			this.notify();
		}
	}
}

public void mySort(){
	int x=11;//语句1
 	int y=12;//语句2
    x=x+5;//语句3
    y=x*x;//语句4
    //即使存在指令重排，这里的语句4不会先执行，因为y和x还没有被声明，即指令重排需保证数据依赖性
}

//分析：
//假设现在有两个线程，第一个线程进入了方法1，然后由于存在指令重排，flag=true被先执行，然后会被其他线程可见
//此时，线程2抢到了执行权，线程2调用了方法2，然后将a=5输出，我们的意思是让结果等于6，但是结果最终等于5。
public class Demo{
	int a=0;
    boolean flag=false;
    public void fun1(){
        a=1;
        flag=true;
    }    
    public void fun2(){
    	if(flag==true){
        	a=a+5;
            System.out.println("a="+a);
        }
    }
}

//版本1：最简单的单例模式（饿汉式）
public class SingletonDemo1 {
	//创建类中的唯一对象
	private static SingletonDemo1 instence=new SingletonDemo1();
	//构造器私有
	private SingletonDemo1(){
	}
	//其他类获取该对象
	public static SingletonDemo1 getInstence(){
		return instence;
	}
	public static void main(String[] args) {
		SingletonDemo1 s1=SingletonDemo1.getInstence();
		SingletonDemo1 s2=SingletonDemo1.getInstence();
		System.out.println(s1==s2);
	}
}

//版本2:当用到这个对象时，再new出来（懒汉式）
public class SingletonDemo2 {
    //
	private static SingletonDemo2 instence=null;
	//构造器私有
	private SingletonDemo2(){
	}
	//其他类获取该对象
	public static SingletonDemo2 getInstence(){
		//用到的时候再创建对象
		if(instence==null){
			instence=new SingletonDemo2();
		}
		return instence;
	}  
	public static void main(String[] args) {
		//多个线程访问
		for (int i = 0; i < 10; i++) {
			new Thread(String.valueOf(i)){
				public void run(){
					System.out.println(SingletonDemo2.getInstence().hashCode());
				}
			}.start();
		}
	}
}

//版本3：DCL模式
public class SingletonDemo3 {
	private static volatile SingletonDemo3 instence=null;
	//构造方法私有，不让其他类再new出来对象
	private SingletonDemo3(){}
	public static  SingletonDemo3 getInstence(){
		//DCL模式(在锁的前后进行双重判断)
		if(instence==null){ 
        //当第一个线程进来了，发现为空，此时第二个线程也进来了，然后线程1抢到了锁，然后获取了new对象，然后释放锁
        //问题：线程2是什么时候知道已经new出来了呢？（因为volatile保证了可见性）
        //此时第二个线程抢到了锁，然后进入了，此时线程2发现instence已经不为空，则直接退出，释放锁。
			synchronized(SingletonDemo3.class){
				if(instence==null){
					instence=new SingletonDemo3();
				}
			}
		}
		return instence;
	}
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			new Thread(String.valueOf(i)){
				public void run(){
					System.out.println(SingletonDemo3.getInstence().hashCode());
				}
			}.start();
		}
	}
}

public class 可重入锁 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Phone p=new Phone();
		new Thread("t1"){
			public void run(){
				p.sendMess();
			}
		}.start();
		System.out.println("======================");
		new Thread("t2"){
			public void run(){
				p.sendMess();
			}
		}.start();
	}	
}
//线程操纵资源类
class Phone{
	public synchronized void sendMess(){
		System.out.println(Thread.currentThread().getName()+"\t sendMess()");
		sendEail();
	}
	public void sendEail(){
		System.out.println(Thread.currentThread().getName()+"\t sendEmail()");
	}
}

public class 可重入锁 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Phone p=new Phone();
		new Thread("t1"){
			public void run(){
				p.sendMess();
			}
		}.start();
		System.out.println("======================");
		new Thread("t2"){
			public void run(){
				p.sendMess();
			}
		}.start();
	}	
}
//线程操纵资源类
class Phone{
	public synchronized void sendMess(){
		System.out.println(Thread.currentThread().getName()+"\t sendMess()");
		sendEail();
	}
	public synchronized void sendEail(){
		System.out.println(Thread.currentThread().getName()+"\t sendEmail()");
	}
}

import java.util.concurrent.TimeUnit;
public class 异常释放锁 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test t=new Test();
		new Thread("t1"){
			public void run(){
				t.fun();
			}
		}.start();
		System.out.println("===================");
		new Thread("t2"){
			public void run(){
				t.fun();
			}
		}.start();
	}
}
//线程操作资源类
class Test{
	int count=0;
	boolean flag=true;
	public synchronized void fun(){
		System.out.println(Thread.currentThread().getName()+"start");
		while(flag){
			count++;
			System.out.println(Thread.currentThread().getName()+"count="+count);
			//线程休眠1秒钟
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			if(count==5){
				//添加异常
				int i=1/0;
				System.out.println(i);
			}
			if(count==10){
				//为了停止循环
				flag=false;
			}
			
		}
	}
}

import java.util.concurrent.TimeUnit;
public class 对象O改变 {
	/*final*/ Object o=new Object();
	 void m(){
		 synchronized(o){
			 while(true){
				try {
					TimeUnit.SECONDS.sleep(1);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName());
			} 
		}
	}
	 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		对象O改变 t=new 对象O改变();
		Thread t1=new Thread("t1"){
			public void run(){
				t.m();
			}
		};
		t1.start();
		//这个的意思是让当前执行的线程暂停下来？？？？
		try {
			TimeUnit.SECONDS.sleep(3);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Thread t2=new Thread("t2"){
			public void run(){
				t.m();
			}
		};
		//此时将o对象变成别的对象,如果没有这句话，则线程2永远也没有机会执行。
		t.o=new Object();
		//然后t2就会拿到这把锁
		t2.start();
	}
}

public class 可重入锁 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Phone p=new Phone();
		new Thread("t1"){
			public void run(){
				p.sendMess();
			}
		}.start();
		System.out.println("======================");
		new Thread("t2"){
			public void run(){
				p.sendMess();
			}
		}.start();
	}	
}
//线程操纵资源类
class Phone{
	public synchronized void sendMess(){
		System.out.println(Thread.currentThread().getName()+"\t sendMess()");
		sendEail();
	}
	public synchronized void sendEail(){
		System.out.println(Thread.currentThread().getName()+"\t sendEmail()");
	}
}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockStudy {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TestRRW t=new TestRRW();
		//定义一个读写锁对
		ReentrantReadWriteLock readWriteLock=new ReentrantReadWriteLock();
		Lock readLock=readWriteLock.readLock();
		Lock writeLock=readWriteLock.writeLock();
		
		//创建18个读锁
		for (int i = 0; i < 18; i++) {
			new Thread(){
				public void run(){
					t.read(readLock);
				}
			}.start();;
		}
		
		for (int i = 0; i < 2; i++) {
			new Thread(){
				public void run(){
					t.write(writeLock, 2);;
				}
			}.start();;
		}
	}

}
//线程操作资源类
class TestRRW{
	public int val=0;
	//读方法(传入锁)
	public void read(Lock lock){
		lock.lock();
		try {
			//模拟读的过程
			TimeUnit.SECONDS.sleep(1);
			System.out.println("读完了");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public void write(Lock lock,int num){
		lock.lock();
		try {
			//模拟写的过程
			TimeUnit.SECONDS.sleep(1);
			this.val=num;
			System.out.println("写完了");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
public class SynchronousBlcokingQueueDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BlockingQueue<String> bq=new SynchronousQueue<>();
		//线程1负责添加
		new Thread("t1"){
			public void run(){
				try {
					bq.put("A");
					System.out.println(Thread.currentThread().getName()+"\t put A");
					
					bq.put("B");
					System.out.println(Thread.currentThread().getName()+"\t put B");
					
					bq.put("C");
					System.out.println(Thread.currentThread().getName()+"\t put C");
				
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			}
		}.start();
		//线层2负责取，但是需要每隔3秒钟取一次
		new Thread("t2"){
			public void run(){
				try {
					//每隔3秒钟我取一次（为了防止刚加进去该没来的及打印，就被取出）
					TimeUnit.SECONDS.sleep(3);
					System.out.println(Thread.currentThread().getName()+"\t "+ bq.take());
					
					TimeUnit.SECONDS.sleep(3);
					System.out.println(Thread.currentThread().getName()+"\t "+ bq.take());
					
					TimeUnit.SECONDS.sleep(3);
					System.out.println(Thread.currentThread().getName()+"\t "+ bq.take());
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}.start();
	}
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class 抛出异常类 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BlockingQueue<String> bq=new ArrayBlockingQueue<>(3);
		System.out.println(bq.add("a"));
		System.out.println(bq.add("b"));
		System.out.println(bq.add("c"));
		System.out.println("=========");
		System.out.println(bq.remove());
		System.out.println(bq.remove());
		System.out.println(bq.remove());
		System.out.println(bq.remove());
	}
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class 抛出异常类 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BlockingQueue<String> bq=new ArrayBlockingQueue<>(3);
		System.out.println(bq.offer("a"));
		System.out.println(bq.offer("b"));
		System.out.println(bq.offer("c"));
		System.out.println(bq.offer("x"));
		System.out.println("=========");
		System.out.println(bq.poll());
		System.out.println(bq.poll());
		System.out.println(bq.poll());
		System.out.println(bq.poll());
	
	}
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class 常用方法介绍 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BlockingQueue<String> bq=new ArrayBlockingQueue<>(3);
		try {
			bq.put("a");
			bq.put("b");
			bq.put("c");
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			bq.take();
			bq.take();
			bq.take();
			bq.take();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
public class 常用方法介绍 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BlockingQueue<String> bq=new ArrayBlockingQueue<>(3);
		try {
			System.out.println( bq.offer("a",3, TimeUnit.SECONDS));
			System.out.println( bq.offer("b",3, TimeUnit.SECONDS));
			System.out.println( bq.offer("c",3, TimeUnit.SECONDS));
			System.out.println( bq.offer("d",3, TimeUnit.SECONDS));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

import java.util.concurrent.TimeUnit;

public class 交替打印 {
	//实现两个线程交替打印ABCD
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Print p=new Print();
		new Thread("t1"){
			public void run(){
				while(true){
					p.print1();		
				}
			}
		}.start();
		
		new Thread("t2"){
			public void run(){
				while(true){
					p.print2();
				}
			}
		}.start();
	}
}
class Print{
	//方法1
	boolean isPrint=false;
	public synchronized void print1(){
		while(isPrint==true){
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("AB");
		isPrint=true;
		this.notify();
	}
	
	public synchronized void print2(){
		//判断
		while(isPrint==false){
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//干活
		System.out.println("CD");
		//通知
		isPrint=false;
		this.notify();
	}
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class 传统版2 {
	//给定一个变量num=0;两线程交替+1；减1操作，共执行5次
	//步骤
	//一：线程		操作（定义方法）		资源类（高内聚，低耦合）
	//二：判断		干活				通知
	//三：
	public static void main(String[] args) {
		shareData sd=new shareData();
		
		new Thread("t1"){
			public void run(){
				//执行5次
				for (int i = 0; i <5; i++) {
					sd.increment();
				}
			}
		}.start();
		
		new Thread("t2"){
			public void run(){
				//执行5次
				for (int i = 0; i <5; i++) {
					sd.decrement();
				}
			}
		}.start();
		
	}

}
//线程操作资源类
class shareData{
	public  int num=0;
	private Lock lock=new ReentrantLock();
	private Condition condition=lock.newCondition();
	public void increment(){
		//加锁
		lock.lock();
			try {
					//先判断
					while(num!=0){
						condition.await();
					}
					//干活
					num++;
					System.out.println(Thread.currentThread().getName()+"\t"+num);
					//通知
					condition.signal();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}finally{
				lock.unlock();
			}
	}
	
	public void decrement(){
		//加锁
		lock.lock();
			try {
					//先判断
					while(num==0){
						condition.await();
					}
					//干活
					num--;
					System.out.println(Thread.currentThread().getName()+"\t"+num);
					//通知
					condition.signal();
				
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}finally{
				lock.unlock();
			}
	}
}

//lock代替sunchronized
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReplaceSynchronized {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TestR t=new TestR();
		for (int i = 0; i < 200; i++) {
			new Thread(){
				public void run(){
					t.fun();
				}
			}.start();
		}
		while(Thread.activeCount()>1){
			Thread.yield();
		}
		System.out.println(t.num);
	}	
	
}
class TestR{
	//加volatile保证可见性
	public volatile int num=0;
	//这里采用ReentrantLock替代synchronized(这种写法成功了)
	Lock lock=new ReentrantLock();
	public void fun(){
		try {
			lock.lock();
			TimeUnit.NANOSECONDS.sleep(1);
			for (int i = 0; i < 1000; i++) {
				num++;
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	
	}
}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class 多线程通信 {
	//题目：A线程打印5次，B线程打印10次，C线程打印15次，交替打印，
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		shareResourse sr=new shareResourse();
		new Thread("A"){
			public void run(){
				while(true){
					sr.print5();		
				}
			}
		}.start();
		new Thread("B"){
			public void run(){
				while(true){
					sr.print10();		
				}
			}
		}.start();
		new Thread("C"){
			public void run(){
				while(true){
					sr.print15();		
				}
			}
		}.start();
	}

}
class shareResourse{
	//标志位
	private int num=1;
	Lock lock=new ReentrantLock();
	Condition a=lock.newCondition();
	Condition b=lock.newCondition();
	Condition c=lock.newCondition();
	
	public void print5(){
		//加锁
		lock.lock();
		try {
			//判断
			while(num!=1){
				a.await();
			}
			//干活
			for (int i = 0; i <5; i++) {
				System.out.println(Thread.currentThread().getName()+"\t"+i);
			}
			//让A歇会
			TimeUnit.SECONDS.sleep(1);
			//更换标志位
			num=2;
			//唤醒B，让B干活
			b.signal();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void print10(){
		//加锁
		lock.lock();
		try {
			//判断
			while(num!=2){
				b.await();
			}
			//干活
			for (int i = 0; i <10; i++) {
				System.out.println(Thread.currentThread().getName()+"\t"+i);
			}
			//让B歇会
			TimeUnit.SECONDS.sleep(1);
			//更换标志位
			num=3;
			//唤醒C，让C干活
			c.signal();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void print15(){
		//加锁
		lock.lock();
		try {
			//判断
			while(num!=3){
				c.await();
			}
			//干活
			for (int i = 0; i <15; i++) {
				System.out.println(Thread.currentThread().getName()+"\t"+i);
			}
			//让c歇会
			TimeUnit.SECONDS.sleep(1);
			//更换标志位
			num=1;
			//唤醒a，让a干活
			a.signal();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
}

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

public class CallableDemo {
	//callable实现创建线程
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		Test t=new Test();
		FutureTask<Integer> ft=new FutureTask<>(t);
		Thread t1=new Thread(ft, "t1");
		t1.start();
		Integer i=100;
		Integer i2=ft.get();
		
		System.out.println(i+i2);
	}
}
//第一步：实现callable接口，重写call()方法
class Test implements Callable<Integer>{
	//重写call()方法
	public Integer  call(){
		//模拟相乘运行时长
		try {
			TimeUnit.SECONDS.sleep(3);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return 1024;
	}
}

public class CountDLDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CountDownLatch cd=new CountDownLatch(6);
		for (int i = 0; i < 6; i++) {
			new Thread(String.valueOf(i)){
				public void run(){
					System.out.println(Thread.currentThread().getName()+"\t 同学上完自习，走了");
					cd.countDown();
				}
			}.start();
		}
		try {
            //后面的主线程需要等待前面的六个线程执行完才能执行。
			cd.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"\t 班长锁门了");
	}

}

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBDemo1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CyclicBarrier cb=new CyclicBarrier(7,new Runnable(){
			public void run(){
				System.out.println("召唤神龙");
			}
		});
		for (int i = 0; i < 7; i++) {
			new Thread(String.valueOf(i)){
				public void run(){
					System.out.println(Thread.currentThread().getName());
					try {
						cb.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (BrokenBarrierException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}.start();
		}
	}
}

//例子2：人满发车
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
//人满发车
public class CyclicBarrierDemo2 {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CyclicBarrier cb=new CyclicBarrier(20, new Runnable(){
			public void run(){
				System.out.println("20人满，发车");
			}
		});
		
		for (int i = 0; i < 100; i++) {
			new Thread(){
				public void run(){
					try {
						cb.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (BrokenBarrierException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}.start();
		}
	}
}

public class SemaphoreDemo {
	//模拟总共有6辆车，然后只有三个停车位置
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//这里模拟只有三个车位
		Semaphore s=new Semaphore(3, true);
		//模拟存在六辆车
		for (int i = 0; i < 6; i++) {
			new Thread(String.valueOf(i)){
				public void run(){
					//申请车位
					try {
						//申请到车位
						s.acquire();
						System.out.println(Thread.currentThread().getName()+"\t 号车已经进来");
						TimeUnit.SECONDS.sleep(3);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}finally{
                        //释放许可
						s.release();
						System.out.println(Thread.currentThread().getName()+"\t 号车已经离开");
					}
				}
			}.start();
		}
		
	}
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPollByhands {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ExecutorService threadpoll=new ThreadPoolExecutor(
				2, 
				5, 
				1L,
				TimeUnit.SECONDS,
				new LinkedBlockingQueue<>(3),
				Executors.defaultThreadFactory(),
				new ThreadPoolExecutor.AbortPolicy());
		
		//模拟十个办理业务人员
		for (int i = 0; i < 10; i++) {
			
			threadpoll.execute(new Runnable(){
				public void run(){
					System.out.println(Thread.currentThread().getName()+"\t 办理业务");
				}
			});
		}
		threadpoll.shutdown();
	}
}

import java.util.ArrayList;
//ArrayList为线程不安全类，因为其add方法没有加锁
public class ArrayListDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<String> al=new ArrayList<>();
		for (int i = 0; i < 30; i++) {
			new Thread(){
				public void run(){
					al.add(String.valueOf(Math.random()));
					System.out.println(al);
				}
			}.start();
		}
	}
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Vector;

//ArrayList为线程不安全类，因为其add方法没有加锁
public class ArrayListDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//ArrayList<String> al=new ArrayList<>();
		//List<String> al=new Vector<>();
		List<String> al=Collections.synchronizedList(new ArrayList<>());
		for (int i = 0; i < 30; i++) {
			new Thread(){
				public void run(){
					al.add(String.valueOf(Math.random()));
					System.out.println(al);
				}
			}.start();
		}
	}
}

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;

public class HashSetDemo {
	public static void main(String[] args) {
		//情况一：并发修改异常
		//HashSet<String> set=new HashSet<>();
		//解决一：采用collections工具类将其转换为线程安全的
		//Set<String> set=Collections.synchronizedSet(new HashSet<>());
		//解决二：采用JUC并发包下的copyOnWriteArraySet类。
		Set<String> set=new CopyOnWriteArraySet<>();
		for (int i = 0; i < 30; i++) {
			new Thread(){
				public void run(){
					set.add(String.valueOf(Math.random()));
					System.out.println(set);
				}
			}.start();
		}
	}

}

import java.util.HashMap;
import java.util.Map;
public class HashMapDemo {
	public static void main(String[] args) {
		
		Map<Long, String> map=new HashMap<>();
		for (int i = 0; i < 30; i++) {
			new Thread(String.valueOf(i)){
				public void run(){
					map.put(Thread.currentThread().getId(),String.valueOf(Math.random()));
					System.out.println(map);
				}
			}.start();
		}
	}
}

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class HashMapDemo {
	public static void main(String[] args) {
		Map<Long, String> map=new ConcurrentHashMap<>();
		for (int i = 0; i < 30; i++) {
			new Thread(String.valueOf(i)){
				public void run(){
					map.put(Thread.currentThread().getId(),String.valueOf(Math.random()));
					System.out.println(map);
				}
			}.start();
		}
	}
}

七、并发工具

1.CountDownLatch

允许一个线程或多个线程等待其他线程操作完成。

当我们调用CountDownLatch的countDown（）方法时，计数器-1，调用await()方法时，会阻塞当前线程，直到计数器为零，会释放所有等待的线程。

适用场景：

2.CyclicBarrier

让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有的线程同时释放。

适用场景：

3.CountDownLatch与CyclicBarrier区别

4.控制并发线程数的Semaphore

信号量是用来控制同时访问特定资源的线程数量，他通过协调各个线程，以保证合理使用公共资源。

5.场景题目

1.如何实现让十个线程同时开始？

方法一：使用CountDownLatch，传递参数为10，来一个线程，调用一下await（），阻塞，并调用下countDown（）方法，计数器减少1，直到为0，同时开始。

方法二：采用CyclicBarrier也可以实现。思路类似。

八、线程池相关面试题

1.你知道哪些线程池？

①.创建固定数量的线程池

通过Executors.newFixedThreadPoll()，线程的数量固定，当前线程数量超过该值，则会进行等待

适用场景：控制最大并发线程数

②.创建单个线程的线程池

通过Executors.newSingleThreadPoll(),线程池中仅有一个线程，保证按序执行。

适用场景：适用于单一线程执行一个任务。

③.创建非固定数量的线程池

通过Executors.newCachedThreadPoll()，创建非固定数量线程的线程池。如果线程数超过了预期，则进行回收，如果无可回收线程，则创建新的线程。

适用于多个生命周期较短的线程。

2.线程池参数

线程池的七大参数：

参数一：核心线程数（corePollSize）

参数二：最大线程数（maximumPollSize）

参数三：空闲线程存活时间（keepAliveTime）

参数四：空闲线程存活时间单位（unit）

参数五：任务队列（workQueue）：存储被提交但是尚未被执行的任务。

参数六：线程工厂（threadFactory）:生成线程池中工作线程的工厂。

参数七：拒绝策略（handler）:拒绝策略：当线程数达到最大线程数量，并且任务队列已经满了时，拒绝更多任务进入线程池中。

3.线程池的执行过程：

a.首先，当创建了线程池后，等待提交的任务申请；

b.然后，线程池调用execute()方法添加一个任务时，线程池会进行如下的判断：

1.如果正在运行的线程数小于核心线程数，此时将创建新的线程执行这个任务。

2.如果正在运行的线程数大于或者等于核心线程数，则会将任务添加到队列中，

3.如果任务队列已经满了且正在运行的线程数小于最大的线程数，则创建非核心线程来执行任务；

4.如果阻塞队列已满，而且正在运行的线程数等于最大线程数，则执行拒绝饱和策略；

c.当一个线程任务执行完成后，会从阻塞队列中取出下一个任务执行；

d.当一个空闲线程超过一定的时间，线程池会进行判断，如果当前线程数超过核心线程数，则会进行线程回收。

4.线程池的抛弃策略

a.终止策略（AbortPolicy）:直接抛出异常，从而中止系统正常运行。

b.调用者运行策略（CallerRunsPolicy）:既不会抛弃任务，也不会抛出异常，而是将任务交给调用者

c.抛弃等待最久策略（DiscardOldestPolicy）：丢弃队里中等待最久的任务，尝试执行新的任务。

d.抛弃策略（DiscardPolicy）:直接不处理，丢弃掉。

5.停止线程池，停止时会接新的任务吗？

终止线程池有两种方法：即shutdown()方法和shutdownNow()方法

a.shutdown()方法执行后，不会接收新的任务，但是会继续执行完当前任务和阻塞队列中等待的任务。

b.shutdownNow()方法执行后，不会接收新的任务，阻塞对列中的任务不会继续执行，也会尝试终止当前正在执行的任务。

6.线程池的好处

①减少资源消耗：线程的创建非常消耗CPU资源，执行完任务的线程不会立即被销毁，而是会再次回到线程池中转为空闲状态。

②提高响应速度：当需要执行任务时，不需要等待线程创建完成就能立即执行任务

③管理线程：通过线程池的方式，能够对线程进行统一管理。

7.线程池的核心线程数如何配置？

a.CPU密集型：指的是需要大量的计算，没有阻塞，cpu一直运行的任务；

核心线程数=cpu核数+1；尽量减少CPU切换。

b.IO密集型：IO密集型任务并不需要一直在执行，根据经验可设置为核心线程数=cpu核数*2.

8.线程池的创建步骤

1.创建：通过ThreadPollExecutor(线程池执行单元)类的构造函数中传入7大参数，通过new关键字创建该类的对象；

2.执行：通过调用线程池的execute()方法，内部传入Runnable的子类对象，等待任务申请执行；

3.关闭：我们可以通过线程池的shutdown()方法或者是shutdownNow()方法关闭线程池

9.什么是线程池

线程池是存储线程的容器，创建一个线程非常消耗资源，尤其是存在大量声明周期较短的线程时，线程池的作用是可以对这些线程线程进行管理，运行结束的线程不会立即被销毁，而是再次回到线程池。

10.如果任务队列是空的，线程池中的核心线程是什么状态？

如果任务队列是空的，线程池中的核心线程一直处于运行状态；

实现：线程池通过队列的take()方法阻塞核心线程（Worker）的run()方法运行,保证核心线程不会被销毁。

线程池调用execute()方***在内部调用addWorker创建一个worker类对象。

11.线程池中的空闲的线程处于什么状态?

如果线程池中等待队列未满，则此时空闲线程处于未被创建的过程；

如果线程池中等待队列已满，而且运行的线程数小于最大线程数，则空闲的线程会执行当前的任务；

如果任务执行完成后，空闲线程超过一定的时间，线程池会进行判断，如果当前线程数>核心线程数，则会回收空闲线程。

12.线程池什么情况下采用FixedThread?什么情况下采用cachedThread?

①如果是线程数量比较固定的情况下，可以使用FixedThreadPool

但是：FixedThreadPooL允许的队列长度是Integer.MAX_VALUE,可能会堆积大量的请求，导致OOM；

②如果是线程数量不固定的情况下，使用cachedThreadPool；

但是：cachedThreadPool允许创建的线程数量最大为Integer.MAX_VALUE，可能会创建大量的线程，导致OOM的发生；

九、其他问题