多线程学习笔记

  几个重要概念

程序：一个静态的概念，一般对应于操作系统中的一个可执行文件。

进程：运行中的程序。一个动态的概念。现代的操作系统都可以同时启动多个进程。

线程：一个进程可以产生多个线程。同多个进程可以共享操作系统的某些资源一样，同一进程的多个线程也可以共享此进程的某些资源(比如：代码、数据)，所以线程又被称为轻量级进程。

  创建线程的三种方法：

1.继承Thread类，重写run（）方法（线程体），可以直接使用Thread类的start（）方法。

   Thread类也是Runable接口的一个实现。

简单创建一个线程：

public class TestThread extends Thread{
    public void run() {
        for(int i=0;i<20;i++) {
            System.out.println("一边听歌");
        }
    }
public static void main(String[] args) {
    TestThread st = new TestThread();
    st.start();
    for(int i=0;i<20;i++) {
        System.out.println("一边敲代码");
    }
}
}

 同时拷贝三张图片：

public class FigDownLoad extends Thread{
    private String url;
    private String name;
    public FigDownLoad(String url, String name) {
        super();
        this.url = url;
        this.name = name;
    }
    public void run() {  //线程体，在开启线程后要做的事
        Copy c = new Copy();
        c.download(url, name);
        System.out.println(name);
    }
    public static void main(String[] args) {
        FigDownLoad fdl1 = new FigDownLoad("图片地址1","图片名称1.jpg");
        FigDownLoad fdl2 = new FigDownLoad("图片地址2","图片名称2.jpg");
        FigDownLoad fdl3 = new FigDownLoad("图片地址3","图片名称3.jpg");
        fdl1.start();
        fdl2.start();
        fdl3.start();
        
    }
public class Copy {
  public void download(String url,String name) {
      try {
        FileUtils.copyURLToFile(new URL(url), new File(name));
    } catch (MalformedURLException e) {
        System.out.println("不合法的url");
        e.printStackTrace();
    } catch (IOException e) {
        System.out.println("下载失败");
        e.printStackTrace();
    }
      
  }
}

}

2.直接实现Runable接口，重写run（）方法（线程体）。这里不能直接使用start（）方法。需要先创建Thread类的对象，再调用。（推荐）

简单实现：

public class TestRunnable implements Runnable{
    private String name;
    
    public TestRunnable(String name) {
        super();
        this.name = name;
    }
    public static void main(String[] args) {
        TestRunnable r1 = new TestRunnable("Lisa");
        TestRunnable r2 = new TestRunnable("Tom");
        Thread t1=new Thread(r1);
        Thread t2=new Thread(r2);
        t1.start();
        t2.start();    
    }
    public void run() {
        for(int i=0;i<5;i++) {
            System.out.println(name);
        }    
    }
}

 抢票（对同一个资源会产生并发问题）：注意，run方法不能向外抛出异常，只能try catch。

public class Test12306 implements Runnable{
    private int ticketNums=20;
    
public static void main(String[] args) {
    Test12306 t = new Test12306();
    
    new Thread(t,"小明").start();
    new Thread(t,"小兰").start();
    new Thread(t,"小芳").start();
}

public void run() {
      while(true) {
         if(ticketNums<0) {
           break;
         }
         try {
        Thread.sleep(200);
         } 
         catch (InterruptedException e) {
             e.printStackTrace();
         }
      System.out.println(Thread.currentThread().getName()+"--->"+ticketNums--);
    }
   
}
}

 龟兔赛跑：

public class TestRace implements Runnable{
private String winner;

public void run() {
     for(int step=1;step<=100;step++) {           
         if(Thread.currentThread().getName().equals("兔子")&&(step==20)) {//兔子走了20步时，休息1ms再跑
             try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
         }         
         System.out.println(Thread.currentThread().getName()+"-->"+step);
         boolean flag = gameOver(step);
         if(flag) {
             break;
         }
     }
} 

private boolean gameOver(int step) {//判断比赛是否结束
    if(winner!=null) {
        return true;
    }else {
        if(step==100) {
            winner=Thread.currentThread().getName();//若有人步数到100了，他就是winner
            System.out.println("winner--->"+winner);
            return true;
        }
    }
    return false;
}
public static void main(String[] args) {
    TestRace tr = new TestRace();
    new Thread(tr,"乌龟").start();
    new Thread(tr,"兔子").start();
    
}
}

 3.实现Callable接口。重写call（）方法（有返回，可throw异常）

public class TestCallable implements Callable{
    private int ticketNums=20;
    public Object call() throws Exception {
          while(true) {
                 if(ticketNums<0) {
                   break;
                 }
              System.out.println(Thread.currentThread().getName()+"--->"+ticketNums--);
            }
          return null;
    }
   public static void main(String[] args) throws InterruptedException, ExecutionException {
       TestCallable tc = new  TestCallable();
       ExecutorService ser = Executors.newFixedThreadPool(3);
       Future <Object> f1 = ser.submit(tc);
       Future <Object> f2 = ser.submit(tc);
       Future <Object> f3 = ser.submit(tc);
       Object o1 = f1.get();
       Object o2 = f2.get();
       Object o3 = f3.get();
       ser.shutdownNow();
   }
}

  静态代理设计模式：

以直接实现Runable接口为例

婚庆公司=Thread类（代理）

具体结婚的人=继承Runable接口的类

结婚=run（）方法

public class TestStaticProxy {
    public static void main(String[] args) {
        new WeddingCompany(new person()).marry();
    }  
}
interface Marry{
    void marry();
}

class person implements Marry{
    public void marry() {
    System.out.println("结婚啦！");    
    }
}

class WeddingCompany implements Marry{
    private Marry customer;
    
    public WeddingCompany(Marry customer) {
        super();
        this.customer = customer;
    }

    public void marry() {
        ready();
    this.customer.marry();
        after();
    }
    private void ready() {
        System.out.println("准备婚礼");    
        }
    private void after() {
        System.out.println("打扫现场");    
        }
}

   Lambda表达式：

用于简化线程的使用。

复习：外部类——>静态内部类——>局部内部类——>匿名内部类——>Lambda表达式

格式：接口名称 对象名称 = ()->{

              方法内容（省略方法声明）
          };

1.以下代码包含五种调用方法方式的比较：

public class TestLambda {
public static void main(String[] args) {
    Like1 l1 = new Like1();
    l1.lambda();//调用外部类
    Like2 l2 = new Like2();
    l2.lambda(); //调用静态内部类（存在于类中）
    
    class Like3 implements ILike{
        public void lambda() {
            System.out.println("局部内部类");
        }
    }
    Like3 l3 = new Like3();//调用局部内部类（存在于方法中）
    l3.lambda();

    ILike l4 = new ILike(){
        public void lambda() {
            System.out.println("匿名内部类");
        }
    };
    l4.lambda();
    
    ILike l5 = ()->{
       System.out.println("lambda表达式");
    };
    l5.lambda();//调用lambda表达式
}
static class Like2 implements ILike{
    public void lambda() {
        System.out.println("静态内部类");
    }
}

}
interface ILike{
    void lambda();
}
class Like1 implements ILike{
    public void lambda() {
        System.out.println("外部类");
    }
}

2.带参的Lambda表达式简化方式：

接口名称 对象名称 = 参数名称-> 方法内容;

public class TestLambdaWithParameters {
    public static void main(String[] args) {
        ILove l1 = (int a)->{
               System.out.println("lamda表达式——>"+a);
            };
            l1.lambda(1);
            
        ILove l2 = a->{   //数据类型可以省略，若只有一个参数，括号也可省略
            System.out.println("lamda表达式——>"+a);
            };
            l2.lambda(2);        
            
        ILove l3 = a-> System.out.println("lamda表达式——>"+a);//若方法只有一行，花括号也可省略    
            l3.lambda(3);    
    }
    
}
interface ILove{
    void lambda(int a);
}

 3.带返回值的Lambda表达式：

接口名称 对象名称 =  (参数列表)->返回内容;（若方法内容不为空，则需要与返回内容一起放花括号中）

public class LambdaNoVoid {
public static void main(String[] args) {
    
    IInterest interst = (a,c)->a+c;//返回a+c
    System.out.println(interst.lambda(10,20));
}
}
interface IInterest{
    int lambda(int a,int b);
}

  线程状态：

 

注意：1.当运行状态变成阻塞状态后，不能马上回到运行状态，必须先回到就绪状态等待。

           2.线程一旦死亡，不可再变成其他状态。

  终止线程的方式：

提供一个boolean型的终止变量，当这个变量置为false，则终止线程的运行。

具体写法：run()方法中写明，终止变量为false时才执行线程体。额外提供一个终止方法，方法内将终止变量置为false。main函数中给出调用终止方法的条件即可。这样在线程运行后，满足main函数指定的终止条件后，调用终止方法，终止变量则变为flag，run（）方法就不再运行，线程终止。

public class BooleanStopThread implements Runnable{
    private boolean flag =true;
    private String name;
    public BooleanStopThread(String name) {
        super();
        this.name = name;
    }
    @Override
    public void run() {
    int i=0;
    while(flag) {//在线程体中说明，只有flag为真，才运行
        System.out.println(name+"--->"+i++);
    }
    }
    public void terminate() {//线程终止方法
        this.flag=false;
    }
    public static void main(String[] args) {
        BooleanStopThread bst = new BooleanStopThread("C罗");
        new Thread(bst).start();
        for(int i=0;i<99;i++) {
            if(i==88) {//写明调用终止方法的条件
                bst.terminate();
                System.out.println("Game over!");
            }
            System.out.println("main-->"+i);
        }
    }
}

   改变运行状态的线程的方法：

1.sleep（）：不释放资源，多用于倒计时或等待时间。运行状态——>阻塞状态

public class ThreadSleep {
public static void main(String[] args) throws InterruptedException {
    Date time = new Date(System.currentTimeMillis()+10000);//创建当前时间的Date类对象
    long ti = time.getTime();//获得当前时间毫秒数
    while(true) {
        System.out.println(new SimpleDateFormat("mm:ss").format(time));//创建特定的格式。将Date对象time转换成该格式并打印
        Thread.sleep(1000);//线程阻塞10秒
        time = new Date(time.getTime()-1000);
        if(ti-10000>time.getTime()) {
            break;
        }    
    }
}
}

2.yield（）：礼让线程，运行状态——>就绪状态

new Thread (()-> {
               for(int i=0;i<100;i++) {
                   System.out.println("lambda"+i);
               }
           }).start();
        for(int i=0;i<100;i++) {
            if(i%20==0) {
                Thread.yield();
            }
            System.out.println("main"+i);
        }

3.join（）：是成员方法，只能通过thread的对象调用。写在哪个线程体中，哪个线程体被阻塞。直到其他线程都执行完，才能继续执行。

public class TestJoin {
public static void main(String[] args) {
    System.out.println("爸爸和儿子买烟的故事");
    Father f = new Father();
    f.start();//开始执行父亲线程体内容
    
}

}
class Father extends Thread{
    public void run(){
        System.out.println("想抽烟，让儿子去买");
        Son s = new Son();
        s.start(); //开始执行儿子线程体内容
        try {
            s.join();//父亲线程被阻塞，给其他线程（儿子）让路，只有儿子线程结束后，才能继续执行
            System.out.println("接过烟，把零钱给儿子");
        } catch (InterruptedException e) {
            System.out.println("孩子走丢了");
            e.printStackTrace();
        }
        
        
    }
}
class Son extends Thread{
    public void run(){
        System.out.println("接过老爸的钱，出门");
        System.out.println("路边有个游戏厅，玩了10秒");
        for(int i=0;i<10;i++) {
            System.out.println(i+"秒过去了...");//每循环一次（过1秒报一次时间）
            try {
                Thread.sleep(1000);//当前线程睡眠1s，重复10次，即10秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("去买烟，买完回家给老爸~");
    }
}

  线程状态观察：

线程阻塞可能有4种原因：1.sleep（）2.join（）3.wait（）4.IO中的read（），write（）

其中1和2使线程变为wait（或timewait）阻塞状态。3和4使线程变为blocked阻塞状态。

观察线程状态：State 对象名称 = 线程名称.getState();

                         System.out.println(对象名称);

使阻塞的线程结束的方法：1.while条件写为（对象名称!=Thread.State.TERMINATED），即线程如果死亡就退出。

 2.用activeCount()方法获取当前活跃线程数，若只剩下主线程，则判定break退出。

int num = Thread.activeCount();
    System.out.println(num);
      if(num==1) {
         break;
      }

public class StateObserver {
    public static void main(String[] args) throws InterruptedException {
        Thread t =new Thread(()-> {
        for(int i=0;i<5;i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        });
        State state = t.getState();
        System.out.println(state);
        
        t.start();
        state = t.getState();
        System.out.println(state);
        /*
        while(state!=Thread.State.TERMINATED) {//线程状态不为结束才运行
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = t.getState();
            System.out.println(state);
        }*/
        
        while(true) {
            int num = Thread.activeCount();
            System.out.println(num);
            if(num==1) {
                break;//只剩下主线程，即该线程结束
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = t.getState();
            System.out.println(state);
        }
        
    }
 
}

  线程优先级：

线程的优先级代表进入就绪状态的线程被调度的概率，最高为10，最低为1，默认为5。

最高优先级：Thread.MAX_PRIORITY

最低优先级：Thread.MIN_PRIORITY

设置优先级：线程对象名.setPriority（）

获得优先级：线程对象名.getPriority（）

public class ThreadPriority {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getPriority());//默认线程优先级为5
        MyPriority mp = new MyPriority();
        Thread t1 = new Thread(mp,"lamer");
        Thread t2 = new Thread(mp,"雅诗兰黛");
        Thread t3 = new Thread(mp,"倩碧");
        Thread t4 = new Thread(mp,"巴黎欧莱雅");
        Thread t5 = new Thread(mp,"相宜本草");
        Thread t6 = new Thread(mp,"大宝");
        
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY-2);
        t3.setPriority(Thread.MAX_PRIORITY-4);
        t4.setPriority(Thread.MAX_PRIORITY-6);
        t5.setPriority(Thread.MIN_PRIORITY+2);
        t6.setPriority(Thread.MIN_PRIORITY);
                
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
    }

}
class MyPriority implements Runnable{

    public void run() {
        System.out.println(Thread.currentThread().getName()+"->"+Thread.currentThread().getPriority());
        Thread.yield();
        
    }
    
}

  守护线程：

线程分为用户线程和守护线程两种。java虚拟机一定会等待用户线程执行完毕。但是若一个线程被设置成守护线程，则java虚拟机则不会等待它执行完毕。

设置方法：线程对象名称.setDaemon(true);

public class TestDaemon {
    public static void main(String[] args) {
        You you = new You();
        Thread t1 = new Thread(you);
        t1.start();
        God god = new God();
        Thread t2 = new Thread(god);
        t2.setDaemon(true);
        t2.start();
    }    
}
class You implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<365*100;i++) {
            System.out.println("happylife~");
        }
        
    }
    
}

class God implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<365*10000;i++) {
            System.out.println("God bless you~");
        }
        
    }
    
}

  其他方法：

设置/获取代理线程名字：setName()，getName()

测试线程是否在线：代理线程对象名称.isAlive()

获取当前在线的线程：Thread.currentThread()

public class TestSetNameisAlive {
    public static void main(String[] args) throws InterruptedException {
        MyInfo mi = new MyInfo("战斗机");
        Thread t = new Thread(mi);
        t.setName("公鸡");
        t.start();
        System.out.println(t.isAlive());
        t.sleep(1000);
        System.out.println(t.isAlive());
        
    }

}
class MyInfo implements Runnable{
    private String name;
    

    public MyInfo(String name) {
        super();
        this.name = name;
    }

    @Override
    public void run() {
    System.out.println(Thread.currentThread().getName()+"--->"+name);
        
    }
}

  三种典型不安全的线程案例：

1.12306抢票：

public class Test12306 implements Runnable{
    private int ticketNums=20;
    
public static void main(String[] args) {
    Test12306 t = new Test12306();
    
    new Thread(t,"小明").start();
    new Thread(t,"小兰").start();
    new Thread(t,"小芳").start();
}

public void run() {
      while(true) {
         if(ticketNums<0) {
           break;
         }
         try {
        Thread.sleep(200);
         } 
         catch (InterruptedException e) {
             e.printStackTrace();
         }
      System.out.println(Thread.currentThread().getName()+"--->"+ticketNums--);
    }
   
}
}

2.两人同时取钱：

public class Unsafe {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚礼金");
        Drawing you = new Drawing(account,80,"你");
        Drawing wife = new Drawing(account,90,"她");
        you.start();
        wife.start();
    }
    

}
class Account{
    int money;
    String name;
    public Account(int money, String name) {
        super();
        this.money = money;
        this.name = name;
    }
    
}

class Drawing extends Thread{
    Account account;
    int drawingmoney;
    int packettotal;
    public Drawing(Account account, int drawingmoney, String name) {
        super(name);
        this.account = account;
        this.drawingmoney = drawingmoney;
    }
    @Override
    public void run() {
        if(account.money-drawingmoney<0) {
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money-=drawingmoney;
        packettotal+=drawingmoney;
        System.out.println(this.getName()+"剩下的钱--->"+account.money);
        System.out.println(this.getName()+"取的钱--->"+packettotal);
        
    }
    
}

3.容器计数：

public class Unsafe2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for(int i=0;i<1000;i++) {
            new Thread(()-> {
                list.add(Thread.currentThread().getName());    
        }).start();
    }
      System.out.println(list.size());
   }
}

  synchronized关键字：

synchronized 方法：

通过在方法声明中加入 synchronized关键字来声明。

synchronized 方法控制对“对象的类成员变量”的访问：每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。

缺陷：若将一个大的方法声明为synchronized 将会大大影响效率。

安全的12306抢票：

public class Safe12306{
    
public static void main(String[] args) {
    SafeTicket t = new SafeTicket();
    new Thread(t,"小明").start();
    new Thread(t,"小兰").start();
    new Thread(t,"小芳").start();
}
}
class SafeTicket implements Runnable{
    private int ticketNums=20;
    private boolean flag = true;
public void run() {
      while(flag) {
         try {
        Thread.sleep(200);
         } 
         catch (InterruptedException e) {
             e.printStackTrace();
         }
      test();
    }
      
}
public synchronized void test(){
    if(ticketNums<0) {
        flag=false;
        return;
    }
     try {
            Thread.sleep(200);
             } 
             catch (InterruptedException e) {
                 e.printStackTrace();
             }   
   System.out.println(Thread.currentThread().getName()+"--->"+ticketNums--);
}
}

synchronized块：

synchronized 块可以让我们精确地控制到具体的“成员变量”，缩小同步的范围，提高效率。

格式：synchronized（对象名称）{ }

安全地取钱：

public class Unsafe {
    public static void main(String[] args) {
        Account account = new Account(200,"结婚礼金");
        Drawing you = new Drawing(account,80,"你");
        Drawing wife = new Drawing(account,90,"她");
        you.start();
        wife.start();
    }
    

}
class Account{
    int money;
    String name;
    public Account(int money, String name) {
        super();
        this.money = money;
        this.name = name;
    }
    
}

class Drawing extends Thread{
    Account account;
    int drawingmoney;
    int packettotal;
    public Drawing(Account account, int drawingmoney, String name) {
        super(name);
        this.account = account;
        this.drawingmoney = drawingmoney;
    }
    @Override
    public void run() {
        test();
        
    }
    public void test() {
        synchronized(account) {
    if(account.money-drawingmoney<0) {
        return;
    }
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    account.money-=drawingmoney;
    packettotal+=drawingmoney;
    System.out.println(this.getName()+"剩下的钱--->"+account.money);
    System.out.println(this.getName()+"取的钱--->"+packettotal);
        }
    }
}

安全容器：

public class Unsafe2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for(int i=0;i<1000;i++) {
            new Thread(()-> {
                synchronized(list) {
                list.add(Thread.currentThread().getName());    
                }
        }).start();
    }
      System.out.println(list.size());
   }
}

 改进版12306：

public class Safe12306{
    
public static void main(String[] args) {
    SafeTicket t = new SafeTicket();
    new Thread(t,"小明").start();
    new Thread(t,"小兰").start();
    new Thread(t,"小芳").start();
}
}
class SafeTicket implements Runnable{
    private int ticketNums=20;
    private boolean flag = true;
public void run() {
      while(flag) {
         try {
        Thread.sleep(200);
         } 
         catch (InterruptedException e) {
             e.printStackTrace();
         }
      test();
    }
      
}
public void test(){
    if(ticketNums<0) {
        flag=false;
        return;
    }synchronized(this) {
        if(ticketNums<0) {
            flag=false;
            return;
        }
     try {
            Thread.sleep(200);
             } 
             catch (InterruptedException e) {
                 e.printStackTrace();
             }   
   System.out.println(Thread.currentThread().getName()+"--->"+ticketNums--);
}
}
}

  同步线程练习：

1.影院选座

public class TestCinema {
public static void main(String[] args) {
    List <Integer> available =new ArrayList<Integer>();
    available.add(1);
    available.add(2);
    available.add(3);
    available.add(6);
    available.add(7);

    List <Integer> seats1 =new ArrayList<Integer>();
    seats1.add(1);
    seats1.add(2);
    List <Integer> seats2 =new ArrayList<Integer>();
    seats2.add(4);
    seats2.add(5);
    Cinema c = new Cinema(available,"happycinema");
    new Thread(new customer(c,seats1),"小明").start();
    new Thread(new customer(c,seats2),"小刚").start();
}
}
class Cinema{
    List <Integer> available;
    String name;
    public Cinema(List <Integer> available, String name) {
        super();
        this.available = available;
        this.name = name;
    }
    public boolean bookTickects(List <Integer>  seats) {
        System.out.println("可用位置为："+available);
        List <Integer> copy =new ArrayList<Integer>();
        copy.addAll(available);
        copy.removeAll(seats);
        if(available.size()-copy.size()!=seats.size()) {
            return false;
        }
        available=copy;
        return true;
    }
}
class customer implements Runnable{
    Cinema cinema;
    List <Integer> seats;
    public customer(Cinema cinema, List<Integer> seats) {
        super();
        this.cinema = cinema;
        this.seats = seats;
    }
    @Override
    public void run() {
        synchronized(cinema) {
        boolean flag = cinema.bookTickects(seats);
        if(flag) {
            System.out.println("出票成功"+Thread.currentThread().getName()+seats);
        }else {
          System.out.println("出票失败"+Thread.currentThread().getName());
        }
        }
    }
    
}

2.买火车票（p218待看）

3.并发容器：

CopyOnWriteArrayList内部自带锁，可以直接替代ArrayList。

CopyOnWriteArrayList <String> list = new CopyOnWriteArrayList<String>();
        for(int i=0;i<1000;i++) {
            new Thread(()-> {            
                list.add(Thread.currentThread().getName());    
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }).start();
    }
      System.out.println(list.size());

  死锁：

“死锁”指的是：多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能进行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。

因此， 某一个同步块需要同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。

死锁程序：

public class TestMakeUp {
    public static void main(String[] args) {
        makeup girl1 =new makeup(0,"大丫");
        makeup girl2 =new makeup(1,"小丫");
        girl1.start();
        girl2.start();
        
    }

}
class lipstick{
    
}
class mirror{
    
}
class makeup extends Thread{
    int choice;
    String girl;
    static lipstick ls = new lipstick();
    static mirror mr = new mirror();

    public makeup(int choice, String girl) {
        super();
        this.choice = choice;
        this.girl = girl;
    }

    @Override
    public void run() {
        makeup();
    }
    private void makeup(){
        if (choice==0) {
            synchronized(ls){
                System.out.println(this.girl+"获得口红");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            synchronized(mr){
                System.out.println(this.girl+"获得镜子");
            }
                
            }
            
        }else {
            synchronized(mr){
                System.out.println(this.girl+"获得镜子");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            synchronized(ls){
                System.out.println(this.girl+"获得口红");
            }
                
            }
            
        }
    }
    
}

解决方法：同一个代码块，不要同时持有两个对象锁。

解除死锁程序：

public class TestMakeUp {
    public static void main(String[] args) {
        makeup girl1 =new makeup(0,"大丫");
        makeup girl2 =new makeup(1,"小丫");
        girl1.start();
        girl2.start();
        
    }

}
class lipstick{
    
}
class mirror{
    
}
class makeup extends Thread{
    int choice;
    String girl;
    static lipstick ls = new lipstick();
    static mirror mr = new mirror();

    public makeup(int choice, String girl) {
        super();
        this.choice = choice;
        this.girl = girl;
    }

    @Override
    public void run() {
        makeup();
    }
    private void makeup(){
        if (choice==0) {
            synchronized(ls){
                System.out.println(this.girl+"获得口红");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
            }
            synchronized(mr){
                System.out.println(this.girl+"获得镜子");
            }
            
        }else {
            synchronized(mr){
                System.out.println(this.girl+"获得镜子");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
            }
            synchronized(ls){
                System.out.println(this.girl+"获得口红");
            }
            
        }
    }
    
}

  并发协作：

生产者/消费者模式：

生产者指的是负责生产数据的模块(这里模块可能是：方法、对象、线程、进程)。

消费者指的是负责处理数据的模块(这里模块可能是：方法、对象、线程、进程)。

消费者不能直接使用生产者的数据，它们之间有个“缓冲区”。生产者将生产好的数据放入“缓冲区”，消费者从“缓冲区”拿要处理的数据。

有了缓冲区以后，生产者线程只需要往缓冲区里面放置数据，而不需要管消费者消费的情况;同样，消费者只需要从缓冲区拿数据处理即可，也不需要管生产者生产的情况。 这样，就从逻辑上实现了“生产者线程”和“消费者线程”的分离。

  编程思路：

管程法：

4个类，分别为数据，缓存区，生产者，消费者。

数据类中包含数据的编号（索引）即可。

缓存区中，需要建立一个数据的数组。写2个同步方法，分别为取数据与放数据。放数据方法中，若数组为空，调用wait（）阻塞使用该方法的线程，否则唤醒线程，放入数据。取数据方法中，若数组已满，调用wait（）阻塞使用该方法的线程，否则唤醒线程，取出数据。

生产者，消费者类须继承Thread类，初始化缓冲区对象，并重写run（）方法，在其中创建数据对象并分别调用缓冲区类中的取数据、放数据方法。

信号灯法：

无缓存区。数据类中定义一个布尔类对象，写2个同步方法（与管程法类似）。不同之处在于信号灯法利用布尔类对象来控制调用wait（）与notyfy（）方法。

  定时调度：

 通过Timer和Timetask，我们可以实现定时启动某个线程。

创建一个类继承TimerTask类，重写run（）方法。

主程序中：

创建Timer类的对象：Timer 对象名称1 = new Timer();
TimerTask 对象名称2 = new 自建类名();
对象名称1.schedule(对象名称2, delay, period);

schedule（）方法的使用非常灵活，可根据实际需求写参数。

public class TestTimerTask {
    public static void main(String[] args) {
        Timer t = new Timer();
        long delay = 1000;
        long period = 1000;
        TimerTask tt = new MyTask();
        t.schedule(tt, delay, period);
    }
    

}
class MyTask extends TimerTask{
   public void run() {
       for(int i=0;i<5;i++) {
           System.out.println("休息时间到~");
       }
   }
    
}

  volatile关键字：

保证数据同步，即线程变量的可见性，可视作一个轻量级的synchronized。

线程对变量进行修改后，立即回写到主内存。

线程读取变量时，从主内存读。

如下程序中，若不加volatile关键字，则cpu读不到num值的改变，程序将进入死循环。

public class TestVolatile {
    private volatile static int num = 0;
public static void main(String[] args) throws InterruptedException {
    new Thread(()-> {
        while(num==0) {
            
        }
        
    }).start();
    Thread.sleep(1000);
    num=1;
}
}

  可重入锁：

如果某个线程试图获取一个已经由它自己持有的锁时，这个请求会立刻成功，且这个锁的计数值加1。当线程退出同步代码块时，计数器减1，计数为0时，锁释放。

若使用普通锁，在第二次试图获得时，会造成死锁。

直接使用ReentrantLock即可。

  CAS（Compare and Swap):

悲观锁：synchronized是独占锁（悲观锁），会导致其他所有需要锁的线程挂起，等待持有锁的线程释放锁。

乐观锁：每次不加锁而是假设没有冲突而去完成某项操作。如果因为冲突失败，就重试，知道成功为止。

实现方法：有三个值：当前内存值V，旧的预期值A，将更新的值B。获取当前内存值V，将其与预期值A比较，若相同，则V修改为B，返回true，否则返回false。

可用商品秒杀来理解：当前商品库存1。多个人抢该商品，预期值都是1。网速最快的人拍下时，当前内存值为1，与预期值相同，则秒杀成功，商品内存改为0。这样别的人再拍，实际内存（0）就与预期值（1）不相同了，秒杀失败。

核心代码：Atomiclnteger 库存对象名称 = new Atomiclnteger（库存数）

Integer 剩余量对象名称 =  库存对象名称.decrementAndGet（）相减同时获取