【博学谷学习记录】超强总结，用心分享。多线程相关点知识学习。

一、实现多线程

　　1.1了解多线程

　　　　多线程是指从软件或硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。

　　1.2并发和并行

　　　　并行：在同一时刻，有多个指令在多个CPU上同时运行。（多个cpu一同运行）

　　　　并发：在同一时刻，有多个指令在单个CPU上交替运行。　（单个cpu上运行多个指令）

　　1.3进程和线程

　　　　进程：是正在运行的程序，具有独立性、动态性和并发性

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

　　1.4实现多线程方式一：继承Tread类

　　　　方法介绍

方法名	说明
void run()	在线程开启后，此方法将被调用执行
void start()	使此线程开始执行，Java虚拟机会调用run方法()

　　　　实现步骤

　　　　　　1）定义一个类MyThead继承Thread类

　　　　　　2）在MyThread类中重写run（）方法

　　　　　　3）创建MyThread类的对象

　　　　　　4）启动线程

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

//        my1.run();
//        my2.run();

        //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
        my1.start();
        my2.start();
    }
}

　　　　问题：1）为什么要重写run（）方法？

　　　　　　　　　　因为run（）是用来封装被线程执行的代码

　　　　　　　　2）run（）方法和start（）方法的区别

　　　　　　　　　　run（）：封装线程执行的代码，直接调用，相当于普通方法的调用

　　　　　　　　　　start（）：启动线程，然后由JVM调用此线程的run（）方法

　　　　1.5实现多线程方式二：实现Runnable接口

　　　　　　Thread构造方法

方法名	说明
Thread(Runnable target)	分配一个新的Thread对象
Thread(Runnable target, String name)	分配一个新的Thread对象

　　　　　实现步骤

　　　　　　定义一个类MyRunnable实现Runnable接口

　　　　　　在MyRunnable类中重写run（）方法

　　　　　　创建Thread类的对象，把MyRunnable对象作为构造方法的参数

　　　　　　启动线程　　　　

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类的对象
        MyRunnable my = new MyRunnable();
        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        Thread t1 = new Thread(my,"坦克");
        Thread t2 = new Thread(my,"飞机");
        //启动线程
        t1.start();
        t2.start();
    }
}

　　　　1.6实现多线程方式三：实现Callable接口

　　　　方法介绍：

方法名	说明
V call()	计算结果，如果无法计算结果，则抛出一个异常
FutureTask(Callable<V> callable)	创建一个 FutureTask，一旦运行就执行给定的 Callable
V get()	如有必要，等待计算完成，然后获取其结果

　　实现步骤：

　　　　定义一个类MyCallable实现Callable接口

　　　　在MyCallable类中重写call（）方法

　　　　创建MyCallable类的对象

　　　　创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数

　　　　创建Thread类的对象，把FutureTask对象作为构造方法的参数

　　　　启动线程

　　　　在调用get方法，就可以获取线程结束后的结果

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }
}
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();

        //Thread t1 = new Thread(mc);

        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);

        //创建线程对象
        Thread t1 = new Thread(ft);

        String s = ft.get();
        //开启线程
        t1.start();

        //String s = ft.get();
        System.out.println(s);
    }
}

　　　　三种实现方式的对比：

　　　　　　实现Runnable、Callable接口：

　　　　　　　　好处：扩展性强、实现该接口的同时还可以继承其他类

　　　　　　　　缺点：编程相对复杂、不能直接使用Thread类中的方法

　　　　　　继承Thread类：

　　　　　　　　好处：编程比较简单，可以直接使用Thread类中的方法

　　　　　　　　缺点：扩展性较差，不能再继承其他的类

　　　　1.7设置和获取线程名称

　　　　方法介绍

方法名	说明
void setName(String name)	将此线程的名称更改为等于参数name
String getName()	返回此线程的名称
Thread currentThread()	返回对当前正在执行的线程对象的引用

public class MyThread extends Thread {
    public MyThread() {}
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

        //void setName(String name)：将此线程的名称更改为等于参数 name
        my1.setName("高铁");
        my2.setName("飞机");

        //Thread(String name)
        MyThread my1 = new MyThread("高铁");
        MyThread my2 = new MyThread("飞机");

        my1.start();
        my2.start();

        //static Thread currentThread() 返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());
    }
}

　　　　1.8线程休眠

方法名	说明
static void sleep(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) throws InterruptedException {
        /*System.out.println("睡觉前");
        Thread.sleep(3000);
        System.out.println("睡醒了");*/

        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

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

　　　　　　1.9线程优先级

　　　　　　　　两种调度方式：

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

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

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

　　　　　　　　随机性

　　　　　　　　相关方法：

方法名	说明
final int getPriority()	返回此线程的优先级
final void setPriority(int newPriority)	更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}
public class Demo {
    public static void main(String[] args) {
        //优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();

        FutureTask<String> ft = new FutureTask<>(mc);

        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        //System.out.println(t1.getPriority());//5
        t1.start();

        MyCallable mc2 = new MyCallable();

        FutureTask<String> ft2 = new FutureTask<>(mc2);

        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        //System.out.println(t2.getPriority());//5
        t2.start();
    }
}

二、线程同步

2.1卖票【应用】

案例需求

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
实现步骤
- 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
- 在SellTicket类中重写run()方法实现卖票，代码步骤如下
- 判断票数大于0，就卖票，并告知是哪个窗口卖的
- 卖了票之后，总票数要减1
- 票卖没了，线程停止
- 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
- 创建SellTicket类的对象
- 创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
- 启动线程

public class SellTicket implements Runnable {
    private int tickets = 100;
    //在SellTicket类中重写run()方法实现卖票，代码步骤如下
    @Override
    public void run() {
        while (true) {
            if(ticket <= 0){
                    //卖完了
                    break;
                }else{
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                }
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        //创建SellTicket类的对象
        SellTicket st = new SellTicket();

        //创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");

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

　　　　问题：相同的票出现了多次和出现了负数的票

　　　　产生原因：线程执行的随机性导致的，可能在卖票过程中丢失CPU的执行权，导致出现问题

　　　　　　2.2同步代码块解决数据安全问题

　　　　　　　　安全问题出现的条件

　　　　　　　　　　多线程环境

　　　　　　　　　　有共享数据

　　　　　　　　　　有多条语句操作共享数据

　　　　　　　　如何解决多线程安全问题？

　　　　　　　　　　基本思路：让程序没有安全问题的环境

　　　　　　　　如何实现：

　　　　　　　　　　把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可　　

　　　　　　　　　　Java提供了同步代码块的方式来解决

　　　　　　　　同步代码块格式：

　　　　　　　　　　synchronized(任意对象) {

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

　　　　　　　　synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

　　　　　　　　同步的好处和弊端

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

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) { // 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
                //t1进来后，就会把这段代码给锁起来
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                        //t1休息100毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //窗口1正在出售第100张票
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--; //tickets = 99;
                }
            }
            //t1出来了，这段代码的锁就被释放了
        }
    }
}

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();

        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

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

　　　　　　2.3同步方法解决数据安全问题【应用】

- - 　　　　同步方法的格式
    
    同步方法：就是把synchronized关键字加到方法上
```
修饰符 synchronized 返回值类型 方法名(方法参数) { 
    方法体；
}
```
    同步方法的锁对象是什么呢?
    
    this
    - - 　　　　静态同步方法
        
        同步静态方法：就是把synchronized关键字加到静态方法上
        
        修饰符 static synchronized 返回值类型方法名(方法参数) {
        方法体；
        }
        
        同步静态方法的锁对象是什么呢?
        
        　　　　类名.class

public class MyRunnable implements Runnable {
    private static int ticketCount = 100;

    @Override
    public void run() {
        while(true){
            if("窗口一".equals(Thread.currentThread().getName())){
                //同步方法
                boolean result = synchronizedMthod();
                if(result){
                    break;
                }
            }

            if("窗口二".equals(Thread.currentThread().getName())){
                //同步代码块
                synchronized (MyRunnable.class){
                    if(ticketCount == 0){
                       break;
                    }else{
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        ticketCount--;
                        System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
                    }
                }
            }

        }
    }

    private static synchronized boolean synchronizedMthod() {
        if(ticketCount == 0){
            return true;
        }else{
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketCount--;
            System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
            return false;
        }
    }
}

　　　　2.5死锁

　　　　　　线程死锁是指由于两个或者多个线程互相持有对象所需要的资源，导致这些线程处于等待状态，无法前往执行

　　　　　　什么情况会产生死锁

　　　　　　　　1.资源有限 2.同步嵌套

public class Demo {
    public static void main(String[] args) {
        Object objA = new Object();
        Object objB = new Object();

        new Thread(()->{
            while(true){
                synchronized (objA){
                    //线程一
                    synchronized (objB){
                        System.out.println("小康同学正在走路");
                    }
                }
            }
        }).start();

        new Thread(()->{
            while(true){
                synchronized (objB){
                    //线程二
                    synchronized (objA){
                        System.out.println("小薇同学正在走路");
                    }
                }
            }
        }).start();
    }
}

posted @ 2022-10-09 18:39 LINwenguan 阅读(15) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

LINwenguan

【博学谷学习记录】超强总结，用心分享 。多线程相关点知识学习。

一、实现多线程

1.7设置和获取线程名称

二、线程同步

2.1卖票【应用】

2.3同步方法解决数据安全问题【应用】

公告

【博学谷学习记录】超强总结，用心分享。多线程相关点知识学习。

　　　　1.7设置和获取线程名称

　　　　　　2.3同步方法解决数据安全问题【应用】