Java学习-第21天-CSDN博客

本文链接：https://blog.csdn.net/sec_90/article/details/122673498

package day_01;
/**
   多线程

       程序 : 一组命令的集合,为了完成指定的功能,程序是静态概念,一般保存在硬盘当中

       进程 : 正在运行的程序,是一个动态概念,需要保存在内存当中,操作系统会生成对应的pid,
               需要CPU时间链来执行,当我们直接关闭某个进程的时候,该进程会在运行内存中被销毁

       线程 : 进程可以进一步细化为线程,一个程序中,不同的执行分支,如果同一个时间节点,
               允许多个线程同时执行的时候,我们称为支持多线程
               在java中,main方法开始执行,就是一个线程,称为主线程


       并行 : 多个CPU,同时执行多个任务

       并发 : 一个CPU,同时执行多个任务

       多线程并行,必须CPU大于等于2才行
       单核CPU没有多线程


*
* @author SEC90
* @Date 2022年1月24日上午9:25:35
*/
public class Thread_01_Create {
   public static void main(String[] args) {
       // test_01();
       test_02();
   }

   public static void test_02() {
       // 创建实现类对象
       Processor_01 p = new Processor_01();
       // 创建线程类对象
       Thread t1 = new Thread(p);
       // 启动线程
       t1.start();
       for (int i = 0; i < 10; i++) {
           System.out.println("main线程-->" + i);
       }
   }

   public static void test_01() {
       // 创建线程类对象
       Thread t1 = new Processor();
       // 调用start方法启动线程
       t1.start();
       for (int i = 0; i < 10; i++) {
           System.out.println("main线程-->" + i);
       }
   }
}

/**
* 第一种创建一个类,继承Thread类并覆写run方法
*
* run方法就等于是新线程中的main方法
*
* @author 天亮教育-帅气多汁你泽哥
* @Date 2022年1月24日上午10:25:31
*/
class Processor extends Thread {
   @Override
   public void run() {
       for (int i = 0; i < 10; i++) {
           System.out.println("测试线程-->" + i);
       }
   }
}

/**
* 第二种创建一个类,实现Runnable接口,并覆写run方法
*
* run方法就等于是新线程中的main方法
*
* @author 天亮教育-帅气多汁你泽哥
* @Date 2022年1月24日上午10:30:40
*/
class Processor_01 implements Runnable {
   @Override
   public void run() {
       for (int i = 0; i < 10; i++) {
           System.out.println("测试线程-->" + i);
       }
   }
}

package day_01;

/**
* getName : 获取线程的名字
*
* setName : 设置线程的名字,如果不设置,默认是Thread-0开始依次递增
*
* setPriority() : 设置优先级,java中有1-10 ,10个优先级等级
*            MIN_PRIORITY = 1
*            NORM_PRIORITY = 5
*            MAX_PRIORITY = 10
*
* getPriority() : 获取优先级等级
*
* static currentThread() : 获取当前线程对象
*
* static sleep() : 让当前线程进入睡眠状态
*
* currentThread和sleep 是静态方法,意味着和哪个对象调用无关
*
* currentThread : 出现在哪个线程中,就获取哪个线程的对象
* sleep : 出现在哪个线程中,就睡眠哪个线程,参数为long类型的毫秒数
*
* @author SEC90
* @Date 2022年1月24日上午10:41:02
*/
public class Thread_02_Priority {
   public static void main(String[] args) {
       // 创建线程对象
       Thread t1 = new Processer();
       // 设置名字
       t1.setName("t1");
       // 设置优先级为10
       t1.setPriority(10);
       // 设置main的优先级为1
       Thread.currentThread().setPriority(1);
       // 启动线程
       t1.start();


       for (int i = 0; i < 10; i++) {
           try {
               // 睡眠500毫秒
               Thread.sleep(500);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           // 获取线程对象并获取线程名字
           System.out.println(Thread.currentThread().getName()+"-->"+i);
       }
   }
}

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

package day_01;

/**
* stop : 终止否个线程执行,该方法已过时,不推荐使用,因为有可能导致死锁
*
* 所以一般使用标识符解决
*
* @author SEC90
* @Date 2022年1月24日上午11:06:05
*/
public class Thread_03_Stop {
   public static void main(String[] args) {
       Processer_03 p = new Processer_03();
       Thread t1 = new Thread(p);
       t1.setName("t1");
       t1.start();

       try {
           Thread.sleep(5000);
           // t1.stop();
           p.flag=true;
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
}

class Processer_03 implements Runnable {
// 加一个标识,标识是否要终止线程
boolean flag = false;

   @Override
   public void run() {
       for (int i = 0; true; i++) {
           // 判断是否要终止
           if (flag) {
               System.out.println(Thread.currentThread().getName() + "线程已被终止");
               return;
           }
           try {
               Thread.sleep(1000);
               System.out
                       .println(Thread.currentThread().getName() + "-->" + i);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
}

package day_01;

/**
* join : 线程合并,让当前线程等待指定线程执行完,再继续执行
*
* @author SEC90
* @Date 2022年1月24日下午2:03:29
*/
public class Thread_04_Join {
   public static void main(String[] args) throws InterruptedException {
       Thread t1 = new Processer_04();
       t1.setName("t1");
       t1.start();
       // 到这里,main就要等着t1线程执行完之后,再继续执行
       t1.join();
       for (int i = 0; i < 10; i++) {
           try {
               // 睡眠500毫秒
               Thread.sleep(500);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           // 获取线程对象并获取线程名字
           System.out.println(Thread.currentThread().getName() + "-->" + i);
       }
   }
}

class Processer_04 extends Thread {
   @Override
   public void run() {
       for (int i = 0; i < 10; i++) {
           try {
               // 睡眠500毫秒
               Thread.sleep(500);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           // 获取线程对象并获取线程名字
           System.out.println(Thread.currentThread().getName() + "-->" + i);
       }
   }
}

package day_01;

/**
* yield : 静态方法,暂停当前正在执行的线程对象,并执行其他等待中的线程
*
* 1 静态方法,意味着跟那个对象调用没有官谢,写在哪个线程中,哪个线程就让位
*
* 2 给同优先级让位,不同优先级不让位
*
* @author SEC90
* @Date 2022年1月24日下午2:07:39
*/
public class Thread_05_Yield {
   public static void main(String[] args) {
       // 创建线程
       Thread t1 = new Thread(new Processor_05());
       t1.setName("t1");
       // 设置t1线程和main线程优先级一致
       t1.setPriority(5);
       Thread.currentThread().setPriority(5);
       // 启动
       t1.start();
       for (int i = 0; i < 10; i++) {
           // 让位
           Thread.yield();
           System.out.println(Thread.currentThread().getName()+"-->"+i);
       }
   }
}
class Processor_05 implements Runnable{
   @Override
   public void run() {
       for (int i = 0; i < 10; i++) {
           System.out.println(Thread.currentThread().getName()+"-->"+i);
       }
   }
}

package day_01;

/**
* 线程同步 : 当多个线程有可能同时操作同一个数据的时候,为了保证数据一致性,需要进行同步执行
*
* 本质是同步数据,是一种安全机制
*
* 异步编程 : 线程之间是完全独立的,相互没有影响
*
* 同步编程 : 线程之间不是完全独立的,相互可能有影响
*
* 同步的场景 : 1 必须是多线程(必须有并发性,才有可能出错) 2 多个线程有可能在同一时间操作同一个数据的可能性 3
* 尤其是同时对数据进行更改操作,查询无所谓
*
* @author SEC90
* @Date 2022年1月24日下午2:25:36
*/
public class Thread_06_Synchroinzation {
   public static void main(String[] args) {
       // 创建账户,余额为3000
       Account act = new Account(3000);
       // 两个线程,每个取1000
       Thread t1 = new Processor_06(act);
       Thread t2 = new Processor_06(act);
       t1.setName("t1");
       t2.setName("t2");
       t1.start();
       t2.start();
   }
}

// 线程类
class Processor_06 extends Thread {
   // 账户
   Account act;

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

   @Override
   public void run() {
       // 取1000
       act.withDraw(1000);
   }
}

// 实体类
class Account {
// 余额
private double balance;

//   public synchronized void withDraw(double money) {
   public void withDraw(double money) {
       // 如果该方法加了synchronized,那么该方法就只能有一个线程执行
       System.out.println(Thread.currentThread().getName() + " 执行了");
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       // 语句块锁
       synchronized (this) {
           // 余额减去取钱金额
           double after = balance - money;
           // 新余额复制给余额
           balance = after; // 2000
           System.out.println(Thread.currentThread().getName() + " 取钱成功,取款 : "
                   + money + "元,剩余 : " + balance + " 元 ");
       }
   }

   public Account(double balance) {
       super();
       this.balance = balance;
   }

   public Account() {
       super();
   }

   public double getBalance() {
       return balance;
   }

   public void setBalance(double balance) {
       this.balance = balance;
   }

}

package day_01;

/**
* synchronized(对象){} 成员语句块锁
*
* 当访问一个对象中加锁的成员方法或者成员成员语句块锁的时候,则该对象中所有加锁的成员方法和成员语句块锁全部锁定
*
* synchronized(类名.class){} 静态语句块锁
*
* 当访问一个类中,加锁的静态方法或者静态语句块锁的时候,则该对象中所有加锁的静态方法和静态语句块锁全部锁定
*
* @author SEC90
* @Date 2022年1月24日下午3:23:53
*/
public class Thread_07_Synchroinzation {
   public static void main(String[] args) {
       MyClass_01 mc = new MyClass_01();
       Thread t1 = new Thread(new Processor_08(mc));
       Thread t2 = new Thread(new Processor_08(mc));
       Thread t3 = new Thread(new Processor_08(mc));
       t1.setName("t1");
       t2.setName("t2");
       t3.setName("t3");
       t1.start();
       // 保证t1先执行,进入m1方法执行睡眠
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       t2.start();
       t3.start();
       // 1秒后 m3执行,3秒后 m1和m2执行
   }
}

class Processor_08 implements Runnable {
MyClass_01 mc;

   public Processor_08(MyClass_01 mc) {
       this.mc = mc;
   }

   @Override
   public void run() {
       // 获取线程名字
       String name = Thread.currentThread().getName();
       if (name.equals("t1")) {
           mc.m1();
       } else if (name.equals("t2")) {
           mc.m2();
       }
       if (name.equals("t3")) {
           mc.m3();
       }
   }
}

// 业务类
class MyClass_01 {
   public synchronized void m1() {
       try {
           Thread.sleep(3000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("加锁的m1方法");
   }

   public synchronized void m2() {
       System.out.println("加锁的m2方法");
   }

   public void m3() {
       System.out.println("未加锁的m3方法");
   }
}

package day_01;

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

/**
* lock 是显示锁,需要手动开启和关闭 synchronized是隐式锁,自动开启,执行完自动关闭
*
* lock只有代码块锁 , 而 synchronized支持方法和代码块锁
*
* lock锁,需要JVM花费较少的时间来进行资源调度.性能相对较好,而有很好的扩展性
*
* 使用顺序 : Lock锁 ---> 同步代码块锁 ---> 方法锁
*
* @author SEC90
* @Date 2022年1月24日下午2:25:36
*/
public class Thread_08_Lock {
   public static void main(String[] args) {
       // 创建账户,余额为3000
       Account1 act = new Account1(3000);
       // 两个线程,每个取1000
       Thread t1 = new Processor_09(act);
       Thread t2 = new Processor_09(act);
       t1.setName("t1");
       t2.setName("t2");
       t1.start();
       t2.start();
   }
}

// 线程类
class Processor_09 extends Thread {
// 账户
Account1 act;

   public Processor_09(Account1 act) {
       this.act = act;
   }

   @Override
   public void run() {
       // 取1000
       act.withDraw(1000);
   }
}

// 实体类
class Account1 {
// 余额
private double balance;

   // 创建锁对象
   Lock lock = new ReentrantLock();

   public void withDraw(double money) {
       System.out.println(Thread.currentThread().getName()+" 进来了");
       // 开始同步
       lock.lock();
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       // 语句块锁
       // 余额减去取钱金额
       double after = balance - money;
       // 新余额复制给余额
       balance = after; // 2000
       System.out.println(Thread.currentThread().getName() + " 取钱成功,取款 : "
               + money + "元,剩余 : " + balance + " 元 ");
       // 解锁
       lock.unlock();
   }

   public Account1(double balance) {
       super();
       this.balance = balance;
   }

   public Account1() {
       super();
   }

   public double getBalance() {
       return balance;
   }

   public void setBalance(double balance) {
       this.balance = balance;
   }

}

package day_01;

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

/**
* 定时器 : 计划任务
*
* 只要有一个计划任务,就会开启一个线程,进行计时,到达指定时间后,由该线程来完成这个任务
*
* @author SEC90
* @Date 2022年1月24日下午3:47:13
*/
public class Thread_09_Timer {
   public static void main(String[] args) {
       // 1 要做的事,也就是任务对象
       // 2 什么时候开始做 , 1000*5 就是5秒之后开始
       // 3 间隔时间,每隔多久做一次 1000*3 每3秒执行一次
       Timer t = new Timer();
       t.schedule(new LogTimerTask(), 1000*5,1000*3);
   }
}

// 创建任务
class LogTimerTask extends TimerTask {
   @Override
   public void run() {
       Date date = new Date();
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
       String time = sdf.format(date);
       System.out.println(time);
   }
}