Java笔记 - 黑马程序员_07(多线程，线程同步，线程池，网络编程入门，UDP通信原理，TCP通信原理，commons-io工具类）

谦逊蓄意，只为飞的更高

已于 2022-07-14 20:50:16 修改

阅读量879

点赞数

分类专栏： Java 文章标签： java 开发语言

于 2022-05-17 08:30:00 首次发布

本文链接：https://blog.csdn.net/weixin_56327704/article/details/124765651

版权

1. 实现多线程

1.1 进程

进程：是正在运行的程序

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

1.2 线程

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

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

举例：

记事本程序
扫雷程序

1.3 多线程的实现方式(方式1)

方式1：继承Thread类

定义一个类MyThread继承Thread类
在MyThread类中重写run()方法
创建MyThread类的对象
启动线程

两个小问题：

为什么要重写run() 方法？

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

run() 方法和start() 方法的区别？

run() ：封装线程执行的代码，直接调用，相当于普通方法的调用
start()：启动线程；然后由JVM调用此线程的run()方法

//1.创建线程类继承Thread类
package demo_01;

public class MyThread extends Thread{
   
    @Override
    public void run() {
   
        for (int i = 0; i < 100; i++) {
   
            System.out.println(i);
        }
    }
}

//2.
package demo_01;

public class MyThreadDemo {
   
    public static void main(String[] args) {
   
        //创建线程对象
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();

        //run() ：封装线程执行的代码，直接调用，相当于普通方法的调用
       /* mt1.run();
        mt2.run();*/

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

1.4 设置和获取线程名称

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

void setName(String name):将此线程的名称更改为等于参数name
String getName() :返回此线程的名称
通过构造方法也可以设置线程名称

如何获取main() 方法所在的线程名称？

public static Thread currentThread() 返回对当前正在执行的线程对象的引用

//1.
package demo_02;

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

//2.
package demo_02;
/*
    Thread类中设置和获取线程名称的方法
            void setName(String name):将此线程的名称更改为等于参数name
            String getName() :返回此线程的名称
*/

public class MyThreadDemo {
   
    public static void main(String[] args) {
   
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();

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

        //Thread（String name）分配一个新的Thread对象
//        MyThread mt1 = new MyThread("高铁");
//        MyThread mt2 = new MyThread("飞机");

        mt1.start();
        mt2.start();

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

1.5 线程调度

线程有两种调度模型

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

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

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

public final int getPriority() :返回此线程的优先级
public final void setPriority(int newPriority):更改此线程的优先级

线程默认优先级是5；线程优先级的范围是：1-10
线程优先级高仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果

//1.
package demo_03;

public class ThreadPriority extends Thread{
   
    @Override
    public void run() {
   
        for (int i = 0; i < 100; i++) {
   
            System.out.println(getName()+":"+i);
        }
    }
}

//2.
package demo_03;

public class ThreadPriorityDemo {
   
    public static void main(String[] args) {
   
        //创建线程对象
        ThreadPriority tp1 = new ThreadPriority();
        ThreadPriority tp2 = new ThreadPriority();
        ThreadPriority tp3 = new ThreadPriority();

        tp1.setName("高铁");
        tp2.setName("飞机");
        tp3.setName("汽车");

        //public final int getPriority()返回此线程的优先级
        /*
        System.out.println(tp1.getPriority());  //5
        System.out.println(tp2.getPriority());  //5
        System.out.println(tp3.getPriority());  //5
        */

        //void setPriority(int newPriority)更改此线程的优先级
        /*
        System.out.println(Thread.MAX_PRIORITY);    //10
        System.out.println(Thread.MIN_PRIORITY);    //1
        System.out.println(Thread.NORM_PRIORITY);   //5
        */

        //设置正确的优先级
        tp1.setPriority(5);
        tp2.setPriority(10);
        tp3.setPriority(1);

        //启动线程
        tp1.start();
        tp2.start();
        tp3.start();
    }
}

1.6 线程控制

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

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

//1.
package demo_04;

public class ThreadSleep extends Thread {
   
    public ThreadSleep() {
   
    }

    public ThreadSleep(String name) {
   
        super(name);
    }

    @Override
    public void run() {
   
        for (int i = 0; i < 100; i++) {
   
            System.out.println(getName() + ":" + i);
            try {
   
                //static void sleep(long millis)使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性
                Thread.sleep(1000);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
    }
}

//2.
package demo_04;

//static void sleep(long millis)使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性

public class ThreadSleepDemo {
   
    public static void main(String[] args) {
   
        ThreadSleep ts1 = new ThreadSleep("曹操");
        ThreadSleep ts2 = new ThreadSleep("刘备");
        ThreadSleep ts3 = new ThreadSleep("孙权");

        ts1.start();
        ts2.start();
        ts3.start();
    }
}

void join() 等待这个线程死亡

//1.
package demo_04;

public class ThreadJoin extends Thread{
   
    @Override
    public void run() {
   
        for (int i = 0; i < 100; i++) {
   
            System.out.println(getName()+":"+i);
        }
    }
}

//2.
package demo_04;
//void join()  等待这个线程死亡
public class ThreadJoinDemo {
   
    public static void main(String[] args) {
   
        //创建线程类对象
        ThreadJoin tj1 = new ThreadJoin();
        ThreadJoin tj2 = new ThreadJoin();
        ThreadJoin tj3 = new ThreadJoin();

        tj1.setName("张三");
        tj2.setName("李四");
        tj3.setName("王五");

        tj1.start();
        try {
   
            //void join()  等待这个线程死亡
            tj1.join();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
}

void setDaemon(boolean on) 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

//1.
package demo_04;

public class ThreadDaemon extends Thread{
   
    @Override
    public void run() {
   
        for (int i = 0; i < 100; i++) {
   
            System.out.println();
        }
    }
}

//2.
package demo_04;
//void setDaemon(boolean on)  将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
public class ThreadDaemonDemo {
   
    public static void main(String[] args) {
   
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();

        td1.setName("关羽");
        td1.setName("张飞");

        //设置主线程为刘备
        Thread.currentThread().setName("刘备");

        //设置守护线程
        td1.setDaemon(true);
        td2.setDaemon(true);

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

1.7 线程生命周期

在这里插入图片描述

1.8 多线程的实现方式(方式2)

方式2：实现Runnable接口

定义一个类MyRunnable实现Runnablef接口
在MyRunnable类中重写run()方法
创建MyRunnable类的对象
创建Thread类的对象，把MyRunnable对像作为构造方法的参数
启动线程

多线程的实现方案有两种

继承Thread类
实现Runnable接口

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

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

//1.
package demo_05;

public class MyRunnable implements Runnable{
   
    @Override
    public void run() {
   
        for (int i = 0; i < 100; i++) {
   
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

//2.
package demo_05;
/*
方式2：实现Runnable接口
        1.定义一个类MyRunnable:实现Runnablef接口
        2.在MyRunnable类中重写run()方法
        3.创建MyRunnable类的对象
        4.创建Thread类的对象，把MyRunnable对像作为构造方法的参数
        5.启动线程
*/
public class MyRunnableDemo {
   
    public static void main(String[] args) {
   
        //创建MyRunnable类的对象
        MyRunnable mr = new MyRunnable();

        //创建Thread类的对象，把MyRunnable对像作为构造方法的参数
        //public Thread(Runnable target)
//        Thread t1 = new Thread(mr);
//        Thread t2 = new Thread(mr);

        //public Thread(Runnable target, String name)
        Thread t1 = new Thread(mr,"高铁");
        Thread t2 = new Thread(mr,"飞机");

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

2. 线程同步

案例：卖票

需求：某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

思路：
①定义一个类SellTicket实现Runnablef接口，里面定义一个成员变量：private int tickets=100；
②在SellTicket类中重写run() 方法实现卖票，代码步骤如下:
A:判断票数大于0，就卖票，并告知是哪个窗口卖的
B:卖了票之后，总票数要减1
C:票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
③定义一个测试类SellTicketDemo,里面有main方法，代码步骤如下
A:创建SellTicket类的对象
B:创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
C:启动线程

//1.定义一个类SellTicket实现Runnable接口
package demo_06;

public class SellTicket implements Runnable {
   
    private int tickets = 100;

    @Override
    public void run() {
   
        while (true) {
   
            if (tickets > 0) {
   
                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                tickets--;
            }
        }
    }
}

//2.定义一个测试类SellTicketDemo,里面有main方法
package demo_06;
/*
定义一个测试类SellTicketDemo,里面有main方法，代码步骤如下
        A:创建SellTicket类的对象
        B:创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
        C:启动线程
*/

public class SellTicketDemo {
   
    public static void main(String[] args) {
   
        //创建SellTicket类的对象
        SellTicket st = new SellTicket();

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

        //启动线程
        th1.start();
        th2.start(

最低0.47元/天解锁文章

谦逊蓄意，只为飞的更高

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java笔记 - 黑马程序员_07(多线程，线程同步，线程池，网络编程入门，UDP通信原理，TCP通信原理，commons-io工具类）

1. 实现多线程1.1 进程进程：是正在运行的程序是系统进行资源分配郑调用的独立单位每一个进程都有它自己的内存空间和系统资源1.2 线程线程：是进程中的单个顺序控制流，是一条执行路径单线程：一个进程如果只有一条执行路径，则称为单线程程序多线程：一个进程如果有多条执行路径，则称为多线程程序举例：记事本程序扫雷程序1.3 多线程的实现方式(方式1)方式1：继承Thread类定义一个类MyThread继承Thread类在MyThread类中重写run()方法创建MyT
复制链接

扫一扫