多线程

2024-03-25 14:35:04

多线程（黑马学习笔记）

1.实现多线程

1.1进程

进程：正在运行的程序

是系统进行资源分配和调用的独立单位
每一个进程都有他自己的内存空间和系统资源

1.2线程

线程：进程中的单个顺序控制流，是一条执行路径

单线程：一个进程如果只有一条执行路径，则称为单线程
多线程：一个进程如果只有多条执行路径，则称为多线程

1.3多线程的实现方式

方式1：继承Thread类

定义一个类MyTread继承Thread类
在MyTread类中重写run（）方法
创建MyThread类的对象
执行多线程

public class MyThread extends Thread{
    public MyThread(String name){
        this.setName(name);
    }
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            //getName()
            System.out.println(getName()+":"+i);
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        
        MyThread my3 = new MyThread("大炮")
        my1.setName("高铁");
        my2.setName("飞机")；

//        my1.run();
 //       my2.run();
        m1.start();
        m2.start();
        
        //获取当前运行线程的名称
        System.out.println(Thread.currentThread().getName());
    }
}

调用run方法并没有导致多线程

void start() 导致此线程开始执行；Java虚拟机调用此线程的run方法

两个问题：

为什么要重写run（）方法？
- 因为run（）是用来封装被线程执行的代码
run（）方法和start（）方法的区别？
- run（）可以直接调用，相当于普通方法的调用
- start（）启动线程：然后有jvm调用此线程的run（）方法

1.4设置和获取线程的名称

Thread类中设置和获取线程名称的方法

void setName(String name):将此线程的名称更改为等于参数name
String getName（）；返回此线程的名称

1.5线程调度

俩种调度模型：

分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
抢占式调度模型：优先让优先级高的线程使用，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一点

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

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

Thread类中设置和获取线程优先级的方法

public final int getPriority():返回此线程的优先级
public final void setPriority(int newPriority): 更改此线程的优先级
- 设置线程的优先级有一定的范围MIN_PRIORITY到MAX_PRIORITY
- NORM_PRIORITY 默认优先级
- 可以通过此方法(Thread.?_PRIORITY)查看优先级
- 优先级高低指代获取cpu时间片的几率高，通过多次的运行才能看到效果

1.6线程控制

方法名	说明
static void sleep(long mills)	是当前正在执行的线程停留（暂停执行）指定的毫秒数
void join()	等待这个线程死亡
void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，（即主线程结束）java虚拟机将退出

![11](res/11.pngpublic class MyThread extends Thread{

    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
        
        try{
            Thread.sleep(1000); //停留1s
        } catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) throws InterruptedException{
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        MyThread my3=new MyThread();
        my3.setName("汽车");
        my1.setName("高铁");
        my2.setName("飞机");

        my1.start();
        my.join();  //只有高铁的线程执行完毕，才能执行其他线程
        my2.start();
        my3.start();
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        my3.setName("汽车");
        my1.setName("高铁");

        
        Thread.currentThread().setName("主线程");
        my1.setDaemon(true);
        my2.setDaemon(true);
        
        my1.start();
        my2.start();
        
        
        for(int i=0;i<10;i++){
            sout(Thread.currentThread().getName()+":"+i);
        }


    }
}

1.7 多线程的生命周期

1.8 实现Runnable接口的方式

方式1：继承Thread类

方式2：

1.定义一个类Runnable接口
2.在Runnable类中重写Runnable接口
3.创建MyRunnable类的对象
4.创建Thread类的对象，把MyRunnable对象作为构造方法的参数
5创建线程

public class MyRunnable implements Runnable{

    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyrunnableDemo {
    public static void main(String[] args) {
        MyRunnable my=new MyRunnable();

        Thread t1=new Thread(my,"高铁");
        Thread t2=new Thread(my,"飞机");
//        t1.setName("");
//        t2.setName("");

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

相比继承Thread类，实现Runnable接口的好处

避免了Java单继承的局限性
社和了多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

2.线程同步

ublic class MyRunnable implements Runnable{

    private int tickets=100;
    @Override
    public void run(){
        //相同的票出现了多次
        while(true){
            //tickets=100
            //t1.t2.t3
            //假设t1抢到了cpu的执行权
            if (tickets > 0) {
                //通过sleep（）方法模拟出票时间
                try {
                    Thread.sleep(100);
                    //t1线程休息100毫秒
                    //t2线程抢到了CPU的执行权,t2线程开始执行,执行到这里时候，t2线程休息100ms
                    //t3线程抢到了CPU的执行权,t3线程开始执行,执行到这里时候，t3线程休息100ms
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //假设线程按照顺序醒过来
                //r1抢到cpu的执行权，在控制台输出
                System.out.println(Thread.currentThread().getName()+"已出售"+tickets);
                tickets--;

            }
        }
    }
}

2.1出现的问题：

相同的票出现了多次
出现了负数的票

问题原因：

线程执行的随机性导致

2.2 数据安全问题的解决

是否是多线程环境
是否有共享数据
是否有多条语句操作共享数据

解决方法：

基本思想：让程序没有安全问题的环境（破坏上述3条其中任一项)
- 实现方法：同步代码块

2.3同步代码块

锁多条语句操作共享数据，可以使用同步代码块实现

格式：

synchronized(任意对象){

多条语句操作共享数据的代码

}
synchronized（任意对象）：相当于给代码加锁，任意对象就可以看成一把锁

public class MyRunnable implements Runnable{

    private int tickets=100;

    private Object obj=new Object();  //任意对象，同一个
    @Override
    public void run(){

        while(true){

            synchronized (obj){
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+"已出售"+tickets);
                    tickets--;

                }
            }
        }
    }
}

同步的好处和弊端

好处：解决了多线程的数据安全问题
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会叫你各地程序的运行效率

2.4同步方法

同步方法：就是把synchronized关键字加到方法上

格式：

修饰符+synchronized +返回值类型 +方法名（方法参数){}

同步方法的锁对象：this

public class MyRunnable implements Runnable{

    private int tickets=100;
    private int x=0;
    @Override
    public void run() {

        while (true) {
            if (x % 2 == 0) {
                synchronized (this){  //此时应与 方法的对象一致 为this
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+"已出售"+tickets);
                    tickets--;

                }
            }
            } else {
                sellTicket();

            }
            x++;
        }
    }

    private synchronized void sellTicket() {

        if (tickets > 0) {
            try {
                Thread.sleep(100);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "已出售" + tickets);
            tickets--;

        }
    }
}

同步静态方法：就是把synchronized关键字加到静态方法上

格式：

修饰符 static synchronized 返回值类型方法名（方法参数）{}
- 其同步静态方法的对象为类对象（MyRunnable.class) 反射会讲

2.5 线程安全的类

StringBuffer：等价于StringBuilder（用法相同）

从版本JDK 5开始，这个类别已经被一个等级类补充了，这个类被设计为使用一个线程StringBuilder 。StringBuilder应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步。

Vector：用法和arraylist一致

从Java 2平台v1.2，这个类被改造为实现List接口，使其成为成员Java Collections Framework 。与新集合实现不同， Vector是同步的。如果不需要线程安全的实现，建议使用ArrayList代替Vector 。

Hashtable：该类实现了一个哈希表，它将键映射到值。任何非null对象都可以用作键值或值。

从Java 2平台v1.2，这个类被改造为实现Map接口，使其成为成员Java Collections Framework 。与新的集合实现不同， Hashtable是同步的。如果不需要线程安全的实现，建议使用HashMap代替Hashtable 。如果需要线程安全的并发实现，那么建议使用ConcurrentHashMap代替Hashtable 。

3.Lock锁

Lock：Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象Condition 。

Lock中提供了获得锁和释放锁的方法

void lock(); 获得锁
void unlock(); 释放锁

Lock是接口不能直接实例化，这里采用他的实现类ReentrantLock来实例化

ReentrantLock的构造方法

ReentrantLock（）：创建一个ReentrantLock的实例

public class MyRunnable implements Runnable{

    private int tickets=100;
    private Lock lock=new ReentrantLock();
    @Override
    public void run() {

        while (true) {
            try {
                lock.lock();
                if (tickets > 0) {

                    try {
                        Thread.sleep(100);

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "已出售" + tickets);
                    tickets--;

                }
            }finally {
                lock.unlock();
            }

        }


    }
}

码农公寓