第二十四章 多线程

1 多线程概述

1.1 什么是进程?什么是线程?

进程就是一个应用程序(1个进程是一个软件)
线程是一个进程中的执行场景/执行单元
一个进程可以启动多个线程

 

1.2 对于Java程序来说,当在Dos命令容器中输入:

java HelloWorld回车之后
会先启动JVM, 而JVM就是一个进程
JVM再启动一个主线程调用main方法
同时再启动一个垃圾回收线程负责看护, 回收垃圾
最起码, 现在的java程序中至少有两个线程并发

 

1.3 进程和线程是什么关系? 举个例子

阿里巴巴: 进程
马云: 阿里巴巴的一个线程
童文红: 阿里巴巴的一个线程

   进程可以看做是现实生活当中的公司
   线程可以看做是公司当中的某个员工


注意:
进程A和进程B的内存独立不共享
线程A和线程B呢?
       在java语言中:
线程A和线程B, 堆内存和方法区内存共享
但是栈内存独立, 一个线程一个栈

假设启动10个线程, 会有10栈空间,每个栈和每个栈之间,互不干扰, 各自执行各自的, 这就是多线程并发
       
火车站, 可以看做是一个进程
   火车站中的每一个售票窗口可以看做是一个线程
   我在窗口1购票, 你可以在窗口2购票, 你不需要等我, 我也不需要等你
   所以多线程并发可以提高效率
   
   java中之所以有多线程机制, 目的就是为了提高程序的处理效率


思考一个问题:
使用了多线程机制之后, main方法结束, 是不是有可能程序也不会结束,  main方法结束只是主线程结束了, 主栈空了, 其它的栈(线程)可能还在压栈弹栈

分析一个问题: 对于单核的CPU来说, 真的可以做到真正的多线程并发吗?
   对于多核的CPU电脑来说, 真正的多线程并发是没问题的
  4核CPU表示同一个时间点上, 可以真正的有4个进程并发执行

   什么是真正的多线程并发?
  t1线程执行t1的
  t2线程执行t2的
  t1不会影响t2, t2也不会影响t1, 这叫做真正的多线程并发
 
单核的CPU表示只有一个大脑:
不能够做到真正的多线程并发, 但是可以做到给人"伪并发"的感觉
对于单核的CPU说来, 在某一个时间点上实际只能处理一件事情, 但是由于CPU的处理速度极快, 多个线程之间频繁切换执行, 给人的感觉是: 多个事情在同时做
   

 

1.4 开启线程的方式

第一种方式: 编写一个类, 直接继承java.lang.Thread, 重写run方法
// 定义线程类
public class MyThread extends Thread {
public void run() {

}
}
// 创建线程对象
MyThread t = new MyThread();
// 启动线程
t.start();

第二种方式: 编写一个类, 实现java.lang.Runnable接口, 实现run方法
// 定义一个可运行的类
public class MyRunnable implements Runnable {
public void run() {

}
}
// 创建线程对象
Thread t = new Thread(new MyRunnable());
// 启动线程
t.start();

注意: 第二种方式实现接口比较常用, 因为一个类实现了接口, 它还可以去继承其它的类, 更灵活

 

1.5 开启线程的第一种方式

package com.bjpowernode.java.thread;

/*
实现线程的第一种方式:
   编写一个类, 直接继承java.lang.Thread,重写run方法
   怎么创建线程对象? new就行了
   怎么启动线程呢? 调用线程对象的start()方法
*/
public class ThreadTest02 {
   public static void main(String[] args) {
       // 这里是main方法,这里的代码属于主线程,在主栈中运行
       // 新建一个分支线程对象
       MyThread myThread = new MyThread();

       // myThread.run(); // 不会启动线程, 不会分配新的分支栈

       // 启动线程
       // start()方法的作用是: 启动一个分支线程, 在JVM中开辟一个新的栈空间, 这段代码任务完成之后, 瞬间就结束了
       // 这段代码的任务只是为了开启一个新的栈空间, 只要新栈空间开出来, start()方法就结束了, 线程就启动成功了
       // 启动成功的线程会自动调用run()方法, 并且run方法在分支线程的栈底部(压栈)
       // run方法在分支栈的栈底部, main方法在主栈的栈底部, run和main是平级的
       myThread.start();

       // 这里的代码还是运行在主线程中
       for(int i = 0; i < 1000; i++) {
           System.out.println("主线程 ---> " + i);
      }
  }
}

class MyThread extends Thread {
   @Override
   public void run() {
       // 编写程序, 这段程序运行在分支线程中(分支栈)
       for (int i = 0; i < 1000; i++) {
           System.out.println("分支线程---> " + i);
      }
  }
}

 

 

 

 

 

1.6 开启线程的第二种方式

package com.bjpowernode.java.thread;

/*
实现线程的第二种方式, 编写一个类实现java.lang.Runnable接口
*/
public class ThreadTest03 {
   public static void main(String[] args) {

       /*
       // 创建一个可运行的对象
       MyRunnable r = new MyRunnable();
       // 将可运行的对象封装成一个线程对象
       Thread t = new Thread(r);
       // 启动线程
       t.start();
        */

       // 合并代码
       Thread t = new Thread(new MyRunnable());

       for(int i = 0; i < 100; i++) {
           System.out.println("主线程---> " + i);
      }

  }
}

// 这并不是一个线程类, 是一个可运行的类, 它还不是一个线程
class MyRunnable implements Runnable {

   @Override
   public void run() {
       for(int i = 0; i < 100; i++) {
           System.out.println("分支线程---> " + i);
      }
  }
}

 

1.7 采用匿名内部类方式创建线程

package com.bjpowernode.java.thread;

/*
采用匿名内部类可以吗?
*/
public class ThreadTest04 {
   public static void main(String[] args) {
       // 创建线程对象, 采用匿名内部类方式
       Thread t = new Thread(new Runnable(){
           @Override
           public void run() {
               for (int i = 0; i < 100; i++) {
                   System.out.println("分支线程---> " + i);
              }
          }
      });

       // 启动线程
       t.start();

       for (int i = 0; i < 100; i++) {
           System.out.println("主支线程---> " + i);
      }
  }
}

 

1.8 线程生命周期

新建状态
就绪状态
运行状态
阻塞状态
死亡状态

 

 

 

 

2 多线程常用方法

2.1 获取当前线程对象

package com.bjpowernode.java.thread;

/*
1 怎么获取当前线程对象?
   Thread t = Thread.currentThread();
   返回值t就是当前线程

2 获取线程对象的名字
   String name = 线程对象.getName();

3 修改线程对象的名字
   线程对象.setName();

4 当线程没有设置名字的时候, 默念的名字有什么规律?
   Thread-0
   Thread-1
   Thread-2
   ...
*/
public class ThreadTest05 {

   public void doSome() {
       // 这样就不行了
       // this.getName();
       // super.getName();
       // 但是这样可以
       String name = Thread.currentThread().getName();
       System.out.println("=====>" + name);
  }

   public static void main(String[] args) {
       ThreadTest05 tt = new ThreadTest05();
       tt.doSome();

       // currentThread就是当前线程对象
       // 这个代码出现在main方法当中, 所以当前线程就是主线程
       Thread currentThread = Thread.currentThread();
       System.out.println(currentThread.getName());  // main

       // 创建线程对象
       MyThread2 t = new MyThread2();
       System.out.println(t.getName());  // Thread-0
       // 设置线程的名字
       t.setName("t1");
       // 获取线程的名字
       String tName = t.getName();
       System.out.println(tName);  // tttt
       // 启动线程
       t.start();

       MyThread2 t2 = new MyThread2();
       System.out.println(t2.getName());  // Thread-1
       t2.setName("t2");
       t2.start();
  }
}

class MyThread2 extends Thread {
   public void run() {
       for (int i = 0; i < 100; i++) {
           // currentThread就是当前线程对象, 当前线程是谁呢?
           // 当t1线程执行run方法, 那么这个当前线程就是t1
           // 当t2线程执行run方法, 那么这个当前线程就是t2
           Thread currentThread = Thread.currentThread();
           System.out.println(currentThread.getName() + "---> " + i);
           System.out.println(super.getName() + "---> " + i);
           System.out.println(this.getName() + "---> " + i);
      }
  }
}

 

2.2 线程的sleep方法

package com.bjpowernode.java.thread;

/*
关于线程的sleep方法:
   static void sleep(long millis)
   1 静态方法: Thread.sleep(1000);
   2 参数是毫秒
   3 作用: 让当前线程进入休眠状态, 进入"阻塞状态", 放弃占有的CPU时间片, 让给其它线程使用
   4 Thread.sleep()方法, 可以做到这种效果:
       间隔特定时间, 去执行一段特定的代码, 每隔多久执行一次

*/
public class ThreadTest06 {
   public static void main(String[] args) {
       // 让当前线程进入休眠, 睡眠5秒针
       // 当前线程是主线程
       try {
           Thread.sleep(1000 * 5);
      } catch (InterruptedException e) {
           e.printStackTrace();
      }

       // 5秒之后执行这里的代码
       // System.out.println("hello world");

       for (int i = 0; i < 10; i++) {
           System.out.println(Thread.currentThread().getName() + "--->" + i);

           // 睡眠1秒
           try {
               Thread.sleep(1000);
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
      }
  }
}

 

2.3 sleep方法的面试题

package com.bjpowernode.java.thread;

/*
关于Thread.sleep()方法的一个面试题
*/
public class ThreadTest07 {
   public static void main(String[] args) {
       // 创建线程对象
       Thread t = new MyThread3();
       t.setName("t");
       t.start();

       // 调用sleep方法
       try {
           // 问题: 这行代码会让线程t进入休眠状态吗?
           // 这行代码的作用是让当前线程进入休眠, 也就是main线程进入休眠
           t.sleep(1000 * 5);  // sleep是静态方法, 在执行的时候还是会转换成Thread.sleep(5 * 1000);
      } catch (InterruptedException e) {
           e.printStackTrace();
      }
       // 5秒之后这行代码执行
       System.out.println("hello World");
  }
}

class MyThread3 extends Thread {
   public void run() {
       for (int i = 0; i < 10000; i++) {
           System.out.println(Thread.currentThread().getName() + "--->" + i);
      }
  }
}

 

2.4 终止线程的睡眠

package com.bjpowernode.java.thread;

/*
sleep睡眠太久了, 如果希望半路上醒来, 你应该怎么办? 也就是说怎么叫醒一个正在睡眠的线程?
   注意: 这个不是终断线程的执行, 是终断线程的睡眠
*/
public class ThreadTest08 {
   public static void main(String[] args) {
       Thread t = new Thread(new MyRunnable2());
       t.setName("t");
       t.start();

       // 希望5秒之后, t线程醒来
       try {
           Thread.sleep(1000 * 5);
      } catch (InterruptedException e) {
           e.printStackTrace();
      }
       // 终断t线程的睡眠 (这种终断睡眠的方式依靠了java的异常处理机制)
       t.interrupt();  // 干扰
  }
}

class MyRunnable2 implements Runnable {

   // 重点: run()当中的异常不能throws, 只能try catch
   // 因为run()方法在父类中没有抛出任何异常, 子类不能比父类抛出更多的异常
   @Override
   public void run() {
       System.out.println(Thread.currentThread().getName() + "---> begin");
       // 睡眠1年
       try {
           Thread.sleep(1000 * 60 * 60 * 24 * 365);
      } catch (InterruptedException e) {
           e.printStackTrace();
      }
       // 1年之后才会执行到这里
       System.out.println(Thread.currentThread().getName() + "---> end");
  }
}

 

2.5 强制终止线程的执行

package com.bjpowernode.java.thread;

/*
在java中如何强行终止一个线程
   这种方式存在很大的缺点: 容易丢失数据, 因为这种方式是直接将线程杀死了
   线程没有保存的数据将会丢失, 不建议使用
*/
public class ThreadTest09 {
   public static void main(String[] args) {
       Thread t = new Thread(new MyRunnable3());
       t.setName("t");
       t.start();

       // 模拟5秒
       try {
           Thread.sleep(1000 * 5);
      } catch (InterruptedException e) {
           e.printStackTrace();
      }

       // 5秒之后强行终止t线程
       t.stop();  // 已过时(不建议使用)
  }
}

class MyRunnable3 implements Runnable {

   @Override
   public void run() {
       for (int i = 0 ; i < 10; i++) {
           System.out.println(Thread.currentThread().getName() + "---> " + i);
           try {
               Thread.sleep(1000);
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
      }
  }
}

 

2.6 合理的终止一个线程的执行

package com.bjpowernode.java.thread;

/*
合理的终止一个线程的执行, 这种方式是很常用的
*/
public class ThreadTest10 {
   public static void main(String[] args) {
       MyRunnable4 r = new MyRunnable4();
       Thread t = new Thread(r);
       t.setName("t");
       t.start();

       // 模拟5秒
       try {
           Thread.sleep(5000);
      } catch (InterruptedException e) {
           e.printStackTrace();
      }

       // 终止线程
       // 你想要什么时候终止t, 你什么时候把run改为false即可
       r.run = false;
  }
}

class MyRunnable4 implements Runnable {

   // 打一个布尔标记
   boolean run = true;

   @Override
   public void run() {
       for (int i = 0; i < 10; i++) {
           if (run) {
               System.out.println(Thread.currentThread().getName() + "---> " + i);
               try {
                   Thread.sleep(1000);
              } catch (InterruptedException e) {
                   e.printStackTrace();
              }
          } else {
               // return就结束了, 你在结束之前还有什么没保存的
               // 在这里可以保存
               // save...
               
               // 终止当前线程
               return;
          }

      }
  }
}

 

 

3 线程调度 (了解)

3.1 线程调度概述

1 常见的线程调度模型有哪些?
   抢占式调度模型
  哪个线程的优先级比较高, 抢到的CPU时间片的概率就高一些/多一些
  java采用的就是抢占式模型
 
   均分式调度模型
  平均分配CPU时间片, 每个线程占有的CPU时间片长度一样,
平均分配, 一切平等

 

3.2 线程调度的方法

实例方法:
void setPriority(int newPriority)  // 设置线程的优先级
int getPriority()  // 获取线程优先级
最低优先级1
   默认优先级是5
   最高优先级是10
   优先级比较高的获取CPU时间片可能会多一些. (但也不完全是, 大概率是高的)

静态方法:
static void yield()  // 让位方法
暂停当前正在执行的线程对象, 并执行其他线程
   yield()方法不是阻塞方法, 让当前线程让位, 让给其它线程
   yield()方法的执行会让当前线程从"运行状态"回到"就绪状态"
注意: 在回到就绪之后, 有可能还会再次抢到        

实例方法:
void join()
   合并线程
   class MyThread {
  public void doSome() {
  MyThread2 t = new MyThread2();
           t.join();  // 当前线程进入阻塞, t线程执行, 直到t线程结束, 当前线程才可以继续执行
  }
  }
   class MyThread2 extends Thread {
 
  }

 

3.3 线程优先级

package com.bjpowernode.java.thread;

/*
了解: 关于线程的优先级
 */
public class ThreadTest11 {
    public static void main(String[] args) {

        // 设置主线程的优先级
        Thread.currentThread().setPriority(1);

        /*
        System.out.println("最高优先级: " + Thread.MAX_PRIORITY);
        System.out.println("最低优先级: " + Thread.MIN_PRIORITY);
        System.out.println("默认优先级: " + Thread.NORM_PRIORITY);
         */

        // 获取当前线程对象, 获取当前线程的优先级
        Thread currentThread = Thread.currentThread();
        // main线程的默认优先级是: 5
        // System.out.println(currentThread.getName() + "线程的默认优先级: " + currentThread.getPriority());

        Thread t = new Thread(new MyRunnable5());
        t.setPriority(10);
        t.setName("t");
        t.start();

        // 优先级较高的, 只是抢到的CPU时间片相对多一些
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "---> " + i);
        }

    }
}

class MyRunnable5 implements Runnable {

    @Override
    public void run() {
        // 获取线程优先级
        // System.out.println(Thread.currentThread().getName() + "线程的默认优先级: " + Thread.currentThread().getPriority() );
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "---> " + i);
        }
    }
}

 

3.4 线程让位

package com.bjpowernode.java.thread;

/*
让位, 当前线程暂停, 回到就绪状态, 让给其它线程
静态方法: Thread.yield();
 */
public class ThreadTest12 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable6());
        t.setName("t");
        t.start();

        for (int i = 1; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---> " + i);
        }
    }
}

class MyRunnable6 implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            // 每100个让位一次
            if (i % 10 == 0) {
                Thread.yield();  // 当前线程暂停一下, 让给主线程
            }
            System.out.println(Thread.currentThread().getName() + "---> " + i);
        }
    }
}

 

3.5 线程合并

package com.bjpowernode.java.thread;

/*
线程合并
 */
public class ThreadTest13 {
    public static void main(String[] args) {
        System.out.println("main begin");

        Thread t = new Thread(new MyRunnable7());
        t.setName("t");
        t.start();

        // 合并线程
        try {
            t.join();  // t合并到当前线程中, 当前线程受阻塞, t线程执行直到结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("main over");
    }
}

class MyRunnable7 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---> " + i);
        }
    }
}

 

 

4 多线程并发环境下, 数据的安全问题

4.1 线程安全

为什么这个是重点?
    以后在开发中, 我们怕项目都是运行在服务器当中, 
	而服务器已经将线程的定义, 线程对象的创建, 线程
	的启动等, 都已经实现完了, 这些代码我们都不需要
	编写
	
	最重要的是: 你要知道, 你编写的程序需要放到一个
	多线程的环境下运行, 你更需要关注的是这些数据在
	多线程并发的环境下是否是安全的
	

 

4.2 什么时候数据在多线程并发的环境下会存在安全问题呢?

三个条件:
	条件1: 多线程并发
	条件2: 有共享数据
	条件3: 共享数据有修改的行为
	
满足以上3个条件之后, 就会存在线程安全问题

 

4.3 怎么解决线程安全问题

当多线程并发的环境下, 有共享数据, 并且这个数据还会被修改, 此时就存在线程安全问题, 怎么解决这个问题?
    线程排队执行 (不能并发)
    用排队执行解决线程安全问题
    这种机制被称为: 线程同步机制
    专业术语叫做: 线程同步, 实际上就是线程不能并发了, 线程必须排队执行
    
怎么解决线程安全问题呀?
	使用"线程同步机制"       
        
线程同步就是线程排队了, 线程排队会牺牲一部分效率, 没办法, 数据安全第一位, 只有数据安全了, 我们才可以谈效率, 数据不安全, 没有办法谈效率的事        

 

4.4 同步和异步

异步编程模型:
	线程t1和线程t2, 各自执行各自的, t1不管t2, t2不管t1
	谁也不需要等谁, 这种编程模型叫做: 异步编程模型
	其实就是: 多线程并发 (效率较高), 异步就是并发
        
同步编程模型:
	线程t1和线程t2, 在线程t1执行的时候, 必须等待t2线程的执行结束, 或者说t2线程执行的时间, 必须等待t1线程执行结束
	两个线程之间发生了等待关系, 这就是同步编程模型
	效率较低, 线程排队执行, 同步就是排队
	

 

4.4 模拟两个线程对同一个账户取款

Account.java

package com.bjpowernode.java.threadsafe;

/*
银行账户
	不使用线程同步机制, 多线程对同一个账户进行取款, 出现线程安全问题
 */
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 withdraw(double money) throws InterruptedException {
        // t1和t2并发这个方法, (t1和t2是两个栈, 两个栈操作堆中同一个对象)
        // 取款之前的余额
        double before = this.getBalance();
        // 取款之后的余额
        double after = before - money;
        // 在这里模拟一下网络延迟
        Thread.sleep(10);
        // 更新余额
        // 思考: t1执行到这里了, 但还没有来得及执行这行代码, t2线程进来withdraw方法了, 此时一定出问题
        this.setBalance(after);
    }
}

AccountThread.java

package com.bjpowernode.java.threadsafe;

public class AccountThread extends Thread {
    // 两个线程必须共享同一个账户对象
    private Account act;

    public AccountThread(Account act) {
        this.act = act;
    }

    public void run() {
        // run方法的执行表示取款操作
        // 假设取款5000
        double money = 5000;
        // 取款
        // 多线程并发执行这个方法
        try {
            act.withdraw(money);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款成功, 余额: " + act.getBalance());
    }
}

Test.java

package com.bjpowernode.java.threadsafe;

public class Test {
    public static void main(String[] args) {
        // 创建账户对象 (只创建一个)
        Account act = new Account("act-001", 10000);

        // 创建两个线程
        Thread t1 = new AccountThread(act);
        Thread t2 = new AccountThread(act);

        // 设置name
        t1.setName("t1");
        t2.setName("t2");

        // 启动线程取款
        t1.start();
        t2.start();

    }
}

 

4.5 synchronized关键字的使用

Account.java

package com.bjpowernode.java.threadsafe2;

/*
银行账户
 */
public class Account {
    // 账号
    private String actno;
    // 余额
    private double balance;

    // 对象
    Object obj = new Object();

    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 withdraw(double money) {
        // 以下这几行代码必须是线程排队的, 不能并发
        // 一个线程把这里的代码全部执行结束之后, 另一个线程才能进来
        /*
        线程同步机制的语法是:
            synchronized() {
                // 线程同步代码块
            }
            synchronized后面小括号中传的这个"数据"是非常关键的
            这个数据必须是多线程共享的数据, 才能达到多线程排队

            ()中写什么?
                那要看你想让哪些线程同步
                假设t1, t2, t3, t4, t5, 有5个线程,
                你只希望t1, t2, t3排队, t4, t5不需要排队, 怎么办?
                你一定要在()中写一个t1, t2, t3共享的对象, 而这个
                对象对于t4, t4来说不是共享的

            这里的共享对象是: 账户对象
            账户对象是共享的, 那么this就是账户对象
            不一定是this, 这里只要是多线程共享的那个对象即可

            在java语言中, 任何一个对象都有"一把锁", 其实这把锁就是标记
            100个对象, 100把锁, 1个对象1把锁

            以下代码的执行原理?
                1 假设t1和t2线程并发, 开始执行以下代码的时候, 肯定有一个先一个后
                2 假设t1先执行了,遇到了synchronized, 这个时候自动找“后面共享对象”的对象锁
                找到之后,并占有这把锁,然后执行同步代码块中的程序,在程序执行过程中一直都是
                占有这把锁的,直到同步代码结束,这把锁才会释放。
                3 假设t1已经占有这把锁,此时t2也遇到synchronized关键字,也会去占有后面共享
                对象的这把锁,结果这把锁被t1占有,t2只能在同步代码块外面等待t1的结束,直到
                t1把同步代码块执行结束了,t1会归还这把锁,此时t2终于等到这把锁,然后t2占有
                这把锁之后,进入同步代码块执行程序。

                这样就达到了线程排队执行
                这里需要注意的是:这个共享对象一定要选好了,这个共享对象一定是你需要排队执
                行的这些线程对象所共享的
         */
        Object obj2 = new Object();
        synchronized(this) {
        // synchronized(obj) {
        // synchronized("abc") {  // "abc"在字符串常量池中
        // synchronized (obj2) {  // 这个就不行了,因为obj2不是共享对象
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }

    }
}

AccountThread.java

package com.bjpowernode.java.threadsafe2;

public class AccountThread extends Thread {
    // 两个线程必须共享同一个账户对象
    private Account act;

    public AccountThread(Account act) {
        this.act = act;
    }

    public void run() {
        // run方法的执行表示取款操作
        // 假设取款5000
        double money = 5000;
        // 取款
        // 多线程并发执行这个方法
        act.withdraw(money);
        System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款成功, 余额: " + act.getBalance());
    }
}

Test.java

package com.bjpowernode.java.threadsafe2;

public class Test {
    public static void main(String[] args) {
        // 创建账户对象 
        Account act = new Account("act-001", 10000);
        Account act2 = new Account("act-002", 10000);

        // 创建两个线程
        Thread t1 = new AccountThread(act);
        Thread t2 = new AccountThread(act);
        Thread t3 = new AccountThread(act2);

        // 设置name
        t1.setName("t1");
        t2.setName("t2");
        t3.setName("t3");

        // 启动线程取款
        t1.start();
        t2.start();
        t3.start();

    }
}

 

4.6 java中有三大变量

实例变量:在堆中
静态变量:在方法区
局部变量:在栈中

以上三大变量中:
	局部变量永远都不会存在线程安全问题
	因为局部变量不共享 (一个线程一个栈)
	局部变量在栈中,所以局部变量永远都不会共享
	
	
实例变量在坑中,堆只有1个
静态变量在方法区中,方法区只有1个
堆和方法区都是多线程共享的,所以可能存在线程安全问题


局部变量和常量:不会有线程安全问题
成员变量:可能会有线程安全问题


如果使用局部变量的话:
	建议使用:StringBuilder
	因为局部变量不存在线程安全问题,选择StringBuilder
	StringBuffer效率比较低
	
	ArrayList是非线程安全的
	Vector是线程安全的
	HashMap/HashSet是非线程安全的
	Hashtable是线程安全的

 

4.7 synchronized出现在实例变量

package com.bjpowernode.java.threadsafe3;

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;
    }

    // 取款的方法
    /*
    在实例方法上可以使用synchronized吗?可以的
        synchronized出现在实例方法上,一定锁的是this
        只能是this,不能是其它的对象
        所以这种方式不灵活

        另外还有一个缺点:
            synchronized出现在实例方法上,表示整个方法体都同步,可能会无故扩大同步的范围。
            导致程序的执行效率降低,所以这种方式不常用

        synchronized使用在实例方法上有什么优点?
            代码写少了

        如果共享的对象就是this,并且需要同步的代码块是整个方法休
        建议使用这种方式
     */
    public synchronized void withdraw(double money) {
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);

    }
}

 

4.8 总结synchronized的三种写法

第一种:同步代码块
	灵活
	synchronized(线程共享对象){
		同步代码块;
	}
	
第二种:在实例方法上使用synchronized
	表示共享对象一定是this
	并且同步代码块是整个方法体

第三种:在静态方法上使用synchronized
	表示找类锁
	类锁永远只有1把
	就算创建了100个对象,类锁也只有1把
	
对象锁:1个对象1把锁,100个对象100把锁
类锁:100个对象,也只是1把锁

 

4.9 synchronized面试题

面试题1

package com.bjpowernode.java.exam1;

// 面试题:doOther方法执行的时候需要等待doSome方法的结束吗?
// 不需要,因为doOther()方法没有synchronized
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc = new MyClass();
        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000);  // 这个睡眠的作用是:为了保证t1线程先执行
        t2.start();

    }
}

class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc) {
        this.mc = mc;
    }
    public void run() {
        if (Thread.currentThread().getName().equals("t1")) {
            mc.doSome();
        }
        if (Thread.currentThread().getName().equals("t2")) {
            mc.doOther();
        }
    }
}

class MyClass {
    public synchronized void doSome() {
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    public void doOther() {
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

面试题2

package com.bjpowernode.java.exam2;

// 面试题:doOther方法执行的时候需要等待doSome方法的结束吗?
// 需要,
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc = new MyClass();
        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000);  // 这个睡眠的作用是:为了保证t1线程先执行
        t2.start();

    }
}

class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc) {
        this.mc = mc;
    }
    public void run() {
        if (Thread.currentThread().getName().equals("t1")) {
            mc.doSome();
        }
        if (Thread.currentThread().getName().equals("t2")) {
            mc.doOther();
        }
    }
}

class MyClass {
    public synchronized void doSome() {
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    public synchronized void doOther() {
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

面试题3

package com.bjpowernode.java.exam3;

// 面试题:doOther方法执行的时候需要等待doSome方法的结束吗?
// 不需要,因为MyClass对象是两个,两把锁
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();

        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000);  // 这个睡眠的作用是:为了保证t1线程先执行
        t2.start();

    }
}

class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc) {
        this.mc = mc;
    }
    public void run() {
        if (Thread.currentThread().getName().equals("t1")) {
            mc.doSome();
        }
        if (Thread.currentThread().getName().equals("t2")) {
            mc.doOther();
        }
    }
}

class MyClass {
    public synchronized void doSome() {
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    public synchronized void doOther() {
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

面试题4

package com.bjpowernode.java.exam4;

// 面试题:doOther方法执行的时候需要等待doSome方法的结束吗?
// 需要,因为静态方法是类锁,不管创建了几个对象,类锁只有1把
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();

        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000);  // 这个睡眠的作用是:为了保证t1线程先执行
        t2.start();

    }
}

class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc) {
        this.mc = mc;
    }
    public void run() {
        if (Thread.currentThread().getName().equals("t1")) {
            mc.doSome();
        }
        if (Thread.currentThread().getName().equals("t2")) {
            mc.doOther();
        }
    }
}

class MyClass {
    // synchronized出现在静态方法上是类锁
    public synchronized static void doSome() {
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    public synchronized static void doOther() {
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

 

4.10 死锁概述

package com.bjpowernode.java.deadlock;

/*
死锁代码要会写
一般面试官要求你会写
只有会写的,才会在以后的开发中注意这个事
因为死锁很难调试
 */
public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();

        // t1和t2两个线程共享o1, o2
        Thread t1 = new MyThread1(o1, o2);
        Thread t2 = new MyThread2(o1, o2);

        t1.start();
        t2.start();
    }
}

class MyThread1 extends Thread {
    Object o1;
    Object o2;
    public MyThread1(Object o1, Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run() {
        synchronized (o1) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2) {

            }
        }
    }
}
class MyThread2 extends Thread {
    Object o1;
    Object o2;
    public MyThread2(Object o1, Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run() {
        synchronized (o2) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1) {

            }
        }
    }
}

 

4.11 开发中解决线程安全问题

是一上来就选择线程同步吗?synchronized
	不是,synchronized会让程序的执行效率降低,用户体验不好。
	系统的用户吞吐量降低,用户检验差,在不得已的情况下才选择线程同步机制。

第一种方案:尽量使用局部变量代替“实例变量和静态变量”。

第二种方案:如果必须是实例变量,那么可以考虑创建多个对象,这样实例变量的内存就不共享了。(1个线程对应1个对象,100个线程对应100个对象,对象不共享,就没有数据安全问题了)

第三种方案:如果不能使用局部变量,对象也不能创建多个,这个时候就只能选择synchronized了,线程同步机制

 

4.12 Object类中的wait和notify方法

第一:wait和notify方法不是线程对象的方式,是java中任何一个java对象都有的方法,因为这两个方法是Object类中自带的。
wait方法和notify方法不是通过线程对象调用,

第二:wait()方法作用?
Object o = new Object();
o.wait();
表示:
让正在o对象上活动的线程进入等待状态,无期限等待,直到被唤醒为止。
o.wait();方法的调用,会让“当前线程(正在o对象上活动的线程)”进入等待状态

第三:notify()方法作用?
Object o = new Object();
o.notify();
表示:
唤醒正在o对象上等待的线程。
还有一个nofityAll()方法:
这个方法是唤醒o对象上处于等待的所有线程。
 
 

4.11守护线程

守护线程
java语言中线程分为两大类:
一类是:用户线程
一类是:守护线程(后台线程)
其中具有代码性的就是:垃圾回收线程(守护线程)
守护线程的特点:
一般守护线程是一个死循环,所有的用户线程只要结束
守护线程自动结束。
注意:主线程main方法是个用户线程
守护线程用在什么地方呢?
每天00:00的时候系统数据自动备份
这个需要使用到定时器,并且我们可以将定时器设置成守护线程
一直在那里看着,每到00:00的时候就备份一次。
如果结束了,守护线程自动退出,没有必要进行数据备份了。


package com.bjpowernode.java.thread;

/*
守护线程
*/
public class ThreadTest14 {
   public static void main(String[] args) {
       Thread t = new BakDataThread();
       t.setName("备份数据的线程");
       // 启动线程之前,将线程设置为守护线程
       t.setDaemon(true);
       t.start();

       // 主线程: 主线程是用户线程
       for (int i = 0; i < 10; i++) {
           System.out.println(Thread.currentThread().getName() + "---> " + i);
           try {
               Thread.sleep(1000);
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
      }
  }
}

class BakDataThread extends Thread {
   public void run() {
       int i = 0;
       // 即使是死循环,但由于该线程是守护者,当用户线程结束,守护线程自动终止
       while (true) {
           System.out.println(Thread.currentThread().getName() + "---> " + (++i));
           try {
               Thread.sleep(1000);
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
      }
  }
}

 

4.12 定时器

定时器的作用:
间隔特定的时间,执行特定的程序
每周要进行银行账户的总账操作
每天要进行数据的备份操作

在实际的开发中,每隔多久执行一段特定的程序,这种需求是很常见的
在java中其实可以采用多种方式实现:
可以使用sleep方法,睡眠,设置睡眠时间,每到这个时间点醒过来执行任务,这种方式是最原始的定时器。(比较low)

在java的类库中已经写好了一个定时器:java.util.Timer,可以直接拿来用。不过这种方式在目前的开发中也很少用,因为现在有很多的高级框架都是支持定时任务的。

在实际的开发中,目前使用较多的是Spring框架提供的SpringTask框架,这个框架只要进行简单的配置,就可以完成定时器的任务


package com.bjpowernode.java.thread;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/*
使用定时器指定定时任务
*/
public class TimerTest {
   public static void main(String[] args) throws ParseException {
       // 创建定时器对象
       Timer timer = new Timer();
       // Timer timer = new Timer(true); // 守护线程的方式

       // 指定定时任务
       // timer.schedule(定时任务,第一次执行时间,间隔多久执行一次);
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
       Date firstTime = sdf.parse("2022-07-31 15:16:00");
       // timer.schedule(new LogTimerTask(), firstTime, 1000 * 10);

       // 采用匿名内部类的方式
       timer.schedule(new TimerTask(){
           @Override
           public void run() {
               SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
               String strTime = sdf.format(new Date());
               System.out.println(strTime + ": 成功完成了一次数据备份!");
          }
      }, firstTime, 1000 * 10);
  }
}

// 编写一个定时任务类
// 假设这是一个记录日志的定时任务
class LogTimerTask extends TimerTask {

   @Override
   public void run() {
       // 编写你需要执行的任务就行了
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
       String strTime = sdf.format(new Date());
       System.out.println(strTime + ": 成功完成了一次数据备份!");
  }
}

 

4.13 实现线程的第三种方式

这种方式实现的线程可以获取线程的返回值
之前讲解的那两种方式是无法获取线程返回值的

思考:
系统委派一个线程去执行一个任务,该线程执行完任务之后,可能会有一个执行结果,我们怎么能拿到这个执行结果呢?


package com.bjpowernode.java.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;  // JUC包下的,属于java的并发包,老JDK中没有这个包,新特性

/*
实现线程的第三种方式
   实现Callable接口
   这种方式的优点:可以获取到线程的执行结果
   这种方式的缺点:效率比较低,在获取t线程执行结果的时候,当前线程受阻塞,效率较低
*/
public class ThreadTest15 {
   public static void main(String[] args) throws Exception{

       // 第一步:创建一个“未来任务类”对象
       // 参数非常重要,需要给一个Callable接口的实现类对象。
       FutureTask task = new FutureTask(new Callable() {
           @Override
           public Object call() throws Exception {  // call方法就相当于run方法,只不过这个有返回值
               // 线程执行一个任务,执行之后可能会有一个执行结果
               // 模拟执行
               System.out.println("call method begin");
               Thread.sleep(1000 * 10);
               System.out.println("call method end");
               int a = 100;
               int b = 200;
               return a + b;  // 自动装箱
          }
      });

       // 创建线程对象
       Thread t = new Thread(task);

       // 启动线程
       t.start();

       // 这里是main方法,这是在主线程中
       // 在主线程中,怎么获取线程的返回结果
       // get()方法的执行会导致当前线程阻塞
       Object obj = task.get();
       System.out.println("线程执行结果: " + obj);

       // main方法这里的程序要想执行必须等待get()方法的结束
       // 而get()方法可能需要很久,因为get()方法是为了拿另一个线程的执行结果
       // 另一外线程执行是需时间的
       System.out.println("hello world");
  }
}
 

 

 

 

posted @   路走  阅读(18)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 一个费力不讨好的项目,让我损失了近一半的绩效!
· 清华大学推出第四讲使用 DeepSeek + DeepResearch 让科研像聊天一样简单!
· 实操Deepseek接入个人知识库
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
点击右上角即可分享
微信分享提示