详解Javase 多线程：彻底搞懂线程(下）

package com.newXianCheng.ThreadSafe;
/**
 * @Description: 银行账户类   
 * @auther:Li Ya Hui
 * @Time:2021年5月14日上午9:25:19
 */
public class Account {
  //账号
  private String actno;
  //余额
  private double balance;
  //无参
  public Account() {
  }
  //有参
  public Account(String actno, double balance) {
    this.actno = actno;
    this.balance = balance;
  }
  //方法
  public String getActno() {
    return actno;
  }
  public void setActno(String actno) {
    this.actno = actno;
  }
  public double getBalance() {
    return balance;
  }
  public void setBalance(double balance) {
    this.balance = balance;
  }
  //取款
  public void withdarw(double money) 
  {
    //取款之前的余额
    double before = this.getBalance();
    //取款之后的余额
    double after = before-money;
    //模拟网络延迟  一定出问题
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    //更新余额
    this.setBalance(after);
  }
}

synchronized(){ //线程同步代码块}

    //取款
  public void withdarw(double money) 
  {
    //以下几行代码必须是线程排队的，不能并发。
    //一个线程把这里的代码全部执行结束之后，另一个线程才能进来
    /*
     *线程同步机制的语法是：
      synchronized()
      {
        //线程同步代码块
      }
     */ 
    synchronized (this) {
      double before = this.getBalance();
      double after = before-money;
      //模拟网络延迟  一定出问题
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      //更新余额
      this.setBalance(after);
    }
  }

synchronized（线程共享对象）{ 同步代码块;}

package com.newXianCheng.ThreadSafe3;
/**
 * 
 * @Description: synchronized 面试题： 第二个线程是否运行的方法是否会
 * @auther:Li Ya Hui
 * @Time:2021年5月16日上午10:46:12
 */
//测试类
public class Exam {
  public static void main(String[] args) {
    System.out.println(~-12);
    System.out.println(~12);
    MyClass mc = new MyClass();
    MyThread t1 = new MyThread(mc);
    MyThread t2 = new MyThread(mc);
    t1.setName("t1");
    t2.setName("t2");
    t1.start();
    try {
      Thread.sleep(1000);//保证t1线程先执行
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    t2.start();
  }
}
//线程类
class MyThread extends Thread
{
  private MyClass mClass ; 
  public MyThread(MyClass myClass) {
    this.mClass = myClass;
  }
  public void run() 
  {
    if(Thread.currentThread().getName().equals("t1")) 
    {
      mClass.doSome();
    }else if(Thread.currentThread().getName().equals("t2")) 
    {
      mClass.doOther();
    }
  }
}
//我的任务类
class MyClass {
  public synchronized void doSome()
  {
    System.out.println("doSome begin");
    try {
      Thread.sleep(1000*3);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("doSome over");
  }
  public  void doOther() {
    System.out.println("doOther begin");
    System.out.println("doOther over");
  }
}

package com.newXianCheng.ThreadSafe3.DeadLock;
/**
 * @Description:
 *        死锁代码要会写
 *        一般面试官要求你写。
 *        只有会写的，才会在以后的开发中注意这个事儿。
 *        因为死锁很难调试
 * @auther:Li Ya Hui
 * @Time:2021年5月16日下午6:55:47
 */
public class DeadLock {
  public static void main(String args[]) 
  {
    Object o1 = new Object();
    Object o2 = new Object();
    Thread t1 = new MyThread1(o1, o2);
    Thread t2 = new MyThread2(o1, o2);
    t1.start();
    t2.start();
  }
}
/**
 * @Description: 死锁演示
 * @auther:Li Ya Hui
 * @Time:2021年5月16日下午6:58:42
 */
class MyThread1 extends Thread{
  Object o1 ;
  Object o2 ;
  public MyThread1(Object o1 , Object o2){
    this.o1 = o1 ;
    this.o2 = o2;
  }
  public void run() 
  {
    synchronized (o2) {
      try {
        Thread.sleep(1);
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
      synchronized (o1) {
        System.out.println("1");
      }
    }
  }
}
class MyThread2 extends Thread{
  Object o1 ;
  Object o2 ;
  public MyThread2(Object o1 , Object o2){
    this.o1 = o1 ;
    this.o2 = o2;
  }
  public void run() 
  {
    synchronized (o1) {
      try {
        Thread.sleep(1);
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
      synchronized (o2) {
        System.out.println("2");
      }
    }
  }
}

package com.newXianCheng.ThreadShouHU;
/**
 * @Description: 守护线程
 * @auther:Li Ya Hui
 * @Time:2021年5月16日下午9:29:31
 */
public class Test01 {
  public static void main(String[] args) {
    Thread t2 = new bakDatathread();
    t2.start();
    Thread t = new bakDatathread();
    t.setName("备份数据的线程");
    //设置守护线程
    //启动线程之前，将线程设置为守护线程
    t.setDaemon(true);
    t.start();
    //主线程 ： 主线程是用户线程
    for (int i = 0; i < 2; i++) {
      System.out.println(Thread.currentThread().getName()+"-->"+i);
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
  }
}
class bakDatathread extends Thread{
  public void run() {
    int i = 0;
    //即使是死循环，但由于该线程是守护者，当用户线程结束后，守护线程自动终止。
    while(true) 
    {
      System.out.println(Thread.currentThread().getName()+"  --  "+(++i));
      try {
        Thread.sleep(1999);
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
  }
}

package com.newXianCheng.CallableTest;
/**
 * @Description: 实现线程的第三种方式：
 *          实现Callable接口
 *          这种方式的优点：可以获取到线程的执行结果。
 *          这种方式的缺点：效率比较低，在获取t线程的时候,当前线程受阻塞，效率较低。
 * @auther:Li Ya Hui
 * @Time:2021年5月19日上午11:13:56
 */
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableTest01 {
  public static void main(String[] args) throws InterruptedException, ExecutionException {
    //第一步，创建一个“未来任务类”对象。
    //参数非常重要：效率比较低，在获取t线程的时候，当前线程受阻塞，效率较低。
    FutureTask task = new FutureTask(new Callable() {
      @Override
      public Object call() throws Exception {
        //线程执行一个任务 ， 执行之后可能会有一个执行结果
        //模拟执行
        System.out.println("call method begin");
        Thread.sleep(1000*3);
        System.out.println("call method end");
        int a=100;
        int b=100;
        return a+b; // (自动装箱 integer)
      }
    });
    //创建线程对象
    Thread t  =new Thread(task);
    //启动线程
    t.start();
    //现在是main方法，主线程中
    //在主线程中，怎么获取t线程的返回结果？
    System.out.println(task.get());
    //main方法这里的程序要想执行必须等待get方法的结束
    //而get()方法可能需要很久。因为get方法是为了那另一个线程的执行结果
    //另一个线程执行是需要时间的。
  }
}