多线程

1 多线程

1.1 程序 进程 线程

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

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

线程 : 一个程序中,不同的执行分支,如果同一个时间节点允许多个线程同时执行的时候,我们称为支持多线程

在Java中,main方法开始执行,就是一个线程,称为主线程

1.2 并行和并发

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

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

多线程并行 必须CPU要大于等于2 才行

单核CPU是没有多线程的

实现多线程

package day_1;

public class Thread_01_Create {
    public static void main(String[] args) {
//            test01();
            test_02();


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


    public static void test01(){
        Thread t1 = new Processor();
        t1.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程-->" + i);
        }
    }
}
/**
 * 第一种 创建一个类  继承Thread类 并覆写run方法
 * run方法 就等于是新线程中的main方法
 */
class Processor extends Thread{
    public void run(){
        for (int i = 0; i < 10; i++) {
            System.out.println("测试线程-->"+i);
        }

    }
}

/**
 * 第二种  创建一个类 实现Runnable接口 并覆写run方法
 *
 */
class Processor_01 implements Runnable{

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

通过Callable的方式

实现步骤 定义一个MyCall类实现Callable接口

在MyCall类当中实现Callable接口的call方法 在主类当中创建MyCall的对象，同时也要创建一个FutureTask的对象，将MyCall类的对象作为参数传递给FutureTask的构造方法

主类创建Thread类的对象，把FutureTask对象作为构造方法的参数传递进去 启动线程

5 public class MyCall implements Callable<String> {
6 @Override
7 public String call() throws Exception {
8 for (int i = 0; i < 100; i++) {
9 System.out.println("表白" + (i + 1) + "次");
10 }
11 return "答应";
12 }
13 }

设置和获取线程名称

 线程休眠

 线程优先级

线程调度

两种调度方式

分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程 占用 CPU 的时间片

抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先 级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

Java使用的是抢占式调度模型

随机性

假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就 是使用权， 才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

 线程同步，已经同步出现问题的解决方法，加方法锁 synchronized  第二种方法 加 lock

package day_1;

/**
 *
 * 线程同步 : 当多个线程有可能同时操作同一个数据的时候,为了保证数据一致性,需要进行同步执行
 *
 * 本质是同步数据,是一种安全机制
 *
 * 异步编程 : 线程之间是完全独立的,相互没有影响
 *
 * 同步编程 : 线程之间不是完全独立的,相互可能有影响
 *
 * 同步的场景 : 1 必须是多线程(必须有并发性,才有可能出错) 2 多个线程有可能在同一时间操作同一个数据的可能性 3
 * 尤其是同时对数据进行更改操作,查询无所谓
 */
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;
    }
    public void run(){
        act.withDraw(1000);
    }
}
//实体类
class Account{
    //余额
    private double balance;
//    public synchronized void withDraw(double money){
//
//    }
    public synchronized void withDraw(double money){
        System.out.println(Thread.currentThread().getName()+"执行了");
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        synchronized (this){
            double after = balance - money;
            balance = after;
            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_1;
/**
 * 定时器 ：定时任务
 * 只要有一个计划任务,就会开启一个线程,进行计时,到达指定时间后,由该线程来完成这个任务
 *
 */

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

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 LogTimeTake(),1000*5,1000*3);
    }
}
//创建任务
class LogTimeTake 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);
    }
}