实现多线程

2021-10-19 03:40:33

进程

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

线程

线程：是进程中的单个顺序控制流，是一条执行路径
单线程：一个进程如果只有一条执行路径，则称为单线程程序举例：记事本程序
多线程：一个进程如果有多条执行路径，则称为多线程程序举例：扫雷程序

多线程的实现方式

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

package MyThreadDemo;
/*      方式1：继承Thread类
               定义一个类MyThread继承Thread类
               在MyThread类中重写run()方法
               创建MyThread类的对象
               启动线程

*/
public class MyThreadDemo1 {
    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();  
    }
}

两个小问题：

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

设置和获取线程名称
- Thread类中设置和获取线程名称的方法
- 如何获取main()方法所在的线程名称呢？
  - public static Thread currentThread()：返回对当前正在执行的线程对象的引用

MyThread类

package MyThreadDemo;

public class MyThread1 extends  Thread{

    public MyThread1(){}

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

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


/*
public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}


*/

执行类

package MyThreadDemo;

public class MyThreadDemo2 {
    public static void main(String[] args) {
//        MyThread1 th1 = new MyThread1();
//        MyThread1 th2 = new MyThread1();
//
//        th1.setName("高铁");
//        th2.setName("飞机");


        //Thread(String name)  分配一个新的 Thread对象。
//        MyThread1 th1 = new MyThread1("高铁");
//        MyThread1 th2 = new MyThread1("飞机");
//
//        th1.start();
//        th2.start();

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

    }
}

线程调度

线程有两种调度模型

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

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

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

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

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

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

package MyThreadDemo;

public class MyThreadDemo3 {
    public static void main(String[] args) {
        ThreadPriority th1 = new ThreadPriority();
        ThreadPriority th2 = new ThreadPriority();
        ThreadPriority th3 = new ThreadPriority();

        th1.setName("高铁");
        th2.setName("飞机");
        th3.setName("汽车");

        //public final int getPriority()：返回此线程的优先级
//        System.out.println(th1.getPriority());
//        System.out.println(th2.getPriority());
//        System.out.println(th3.getPriority());

        //public final void setPriority(int newPriority)：更改此线程的优先级
//        th1.setPriority(10000);

//        System.out.println(Thread.MAX_PRIORITY);
//        System.out.println(Thread.MIN_PRIORITY);
//        System.out.println(Thread.NORM_PRIORITY);

        //设置正确优先级
        th1.setPriority(5);
        th2.setPriority(10);
        th3.setPriority(1);

        th1.start();
        th2.start();
        th3.start();
    }
}

线程控制

ThreadSleep类

package MyThreadDemot;

public class ThreadSleep  extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+","+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试代码

package MyThreadDemot;
/*
            static void sleep(Long millis)，使当前正在执行的线程停留(暂停执行)指定的毫秒数
*/
public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep s1 = new ThreadSleep();
        ThreadSleep s2 = new ThreadSleep();
        ThreadSleep s3 = new ThreadSleep();

        s1.setName("黄忠");
        s2.setName("赵云");
        s3.setName("马超");

        s1.start();
        s2.start();
        s3.start();
    }
}

ThreadJoin类

package MyThreadDemot;

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

测试代码

package MyThreadDemot;

public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin s1 = new ThreadJoin();
        ThreadJoin s2 = new ThreadJoin();
        ThreadJoin s3 = new ThreadJoin();


        s1.setName("钟");
        s2.setName("涛");
        s3.setName("猛");

        s1.start();
        try {
            s1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        s2.start();
        s3.start();
    }
}

ThreadDaemon类

package MyThreadDemot;

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

测试代码

package MyThreadDemot;



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


public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon d1 = new ThreadDaemon();
        ThreadDaemon d2 = new ThreadDaemon();

        d1.setName("关羽");
        d2.setName("张飞");

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

        //设置守护线程
        d1.setDaemon(true);
        d2.setDaemon(true);


        d1.start();
        d2.start();

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

线程生命周期

实现多线程

多线程的实现方式

方式2：实现Runnable实现Runnable接口
在MyRunnable类中重写run()方法
创建MyRunnable类的对象
创建Thread类的对象，把MyRunnable对象作为构造方法的参数
启动线程

实现方案有两种

继承Thread类
实现Runnable接口

相比继承Thread类，实现Runnable接口的好处
- 避免了java单继承的局限性
- 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码，数据有效分离，较好的体现了面向对象的设计思路

package MyThreadDemo;

public class MyRunnableDemo1 {
    public static void main(String[] args) {
        //创建MyRunnbale类的对象
        MyRunnable my = new MyRunnable();
        

        //创建Thread类对象，把MyRunnable对象作为构造方法的参数
//        Thread(Runnable target)  分配一个新的 Thread对象。
//        Thread t1 = new Thread(my);
//        Thread t2 = new Thread(my);
//        Thread(Runnable target, String name) 分配一个新的 Thread对象。
        Thread t1 = new Thread(my,"高铁");
        Thread t2 = new Thread(my,"飞机");


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

案例卖票

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

定义一个类SellTicker实现Runnbale接口，里面定义一个成员变量：private int tickets = 100；
在SellTicker类中重写run()方法实现卖票，代码步骤如下：

A：判断票数大于0，就卖票，并告知是哪个窗口卖的
B：卖了票之后总票数减1；
C：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行

定义一个测试类SellTickerDemo，里面有main方法，代码步骤如下

A：创建SellTicker类的对象
B：创建三个Thread类的对象，把SellTIcker对象作为构造方法的参数，并给出对应的窗口名称
C：启动线程

SellTicker类

package MyThreadDemo;

public class SellTicker implements Runnable {
    private int tickers = 100;

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

            }
        }
    }
}

SellTickerDemo测试类

package MyThreadDemo;

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

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


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

卖票案例的思考

修改卖票的动作，每次出票时间100毫秒
卖票出现了问题

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

问题原因

线程执行的随机性导致的

SellTicker类

package MyThreadDemo;

public class SellTicker implements Runnable {
    private int tickers = 100;

    @Override
    public void run() {
        //相同的票出现了多次
//        while (true) {
//            //tickers = 100;
//            //t1,t2,t3
//            //假设t1的线程抢到CPU的执行权
//            if (tickers > 0) {
//                //通过sleep()方法来模拟出票时间
//                try {
//                    Thread.sleep(100);
//                    //t1线程休息100毫秒
//                    //t2线程检测了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程也休息100毫秒
//                    //t3线程检测了CPU的执行权，t2线程就开始执行，执行到这里的时候，t3线程也休息100毫秒
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                //假设线程按照顺序醒过来
//                //t1抢到CPU的执行权，在控制台输出，窗口1正在出售第100张票

//                System.out.println(Thread.currentThread().getName() + "正在出售票" + tickers + "张票");

//                //t2抢到了CPU的执行权，在控制台输出，窗口2正在出售第100张票
//                //t3抢到了CPU的执行权，在控制台输出，窗口3正在出售第100张票
//                tickers--;
//
//                //如果这三个线程还是按照顺序来，这里就执行了3次--操作，最终票就变成了97
//            }
//        }

        //出现了负数的票
        while (true) {
            //tickers = 100;
            //t1,t2,t3
            //假设t1的线程抢到CPU的执行权
            if (tickers > 0) {
                //通过sleep()方法来模拟出票时间
                try {
                    Thread.sleep(100);
                    //t1线程休息100毫秒
                    //t2线程检测了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程也休息100毫秒
                    //t3线程检测了CPU的执行权，t2线程就开始执行，执行到这里的时候，t3线程也休息100毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //假设线程按照顺序醒过来
                //t1 抢到了CPU的执行权，在控制台输出，窗口1正在出售第1张票
                //假设t1继续拥有CPU的执行权，就会执行tickers--，操作，tickers = 0
                //t1 抢到了CPU的执行权，在控制台输出，窗口1正在出售第0张票
                //假设t2继续拥有CPU的执行权，就会执行tickers--，操作，tickers = -1
                //t3 抢到了CPU的执行权，在控制台输出，窗口1正在出售第-1张票
                //假设t3继续拥有CPU的执行权，就会执行tickers--，操作，tickers = -2
                System.out.println(Thread.currentThread().getName() + "正在出售票" + tickers + "张票");
                tickers--;
            }
        }
    }
}

MyTheread测试代码

package MyThreadDemo;
/*
            需求：某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
            思路：
                    定义一个类SellTicker实现Runnbale接口，里面定义一个成员变量：private int tickets = 100；
                    在SellTicker类中重写run()方法实现卖票，代码步骤如下：
                             A：判断票数大于0，就卖票，并告知是哪个窗口卖的
                             B：卖了票之后总票数减1；
                             C：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
                    定义一个测试类SellTickerDemo，里面有main方法，代码步骤如下
                            A：创建SellTicker类的对象
                            B：创建三个Thread类的对象，把SellTIcker对象作为构造方法的参数，并给出对应的窗口名称
                            C：启动线程


*/
public class MyThreadDemo4 {
    public static void main(String[] args) {
        SellTicker st = new SellTicker();

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


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

卖票案例数据安全问题的解决

为什么出现问题？(这也是我们判断多线程程序是否会有数据安全问题的标准)

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

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

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

怎么实现呢？

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

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

同步代码块

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

　　　　　　synchronized(任意对象){

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

　　　　　　}

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

SellTicker类

package MyThreadDemo;

public class SellTicker1 implements Runnable{
    private int tickers = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj) {
                if (tickers > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在出售票" + tickers + "张票");
                    tickers--;
                }
            }
        }
    }
}

测试代码

package MyThreadDemo;

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

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


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

同步的好处和弊端

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

同步方法

就是把synchronized关键字加到方法上
格式：

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

同步方法的锁对象是什么呢？

this

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

格式：

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

同步静态方法的锁对象是什么？
- 类名.class

package MyThreadDemo;

public class SellTicker2 implements Runnable {
//    private int tickers = 100;
    private static int tickers = 100;
    private Object obj = new Object();
    private int x = 0;

    @Override
    public void run() {
        while (true) {
            if (x % 2 == 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
//                synchronized (obj)
//                        synchronized (this){
                synchronized (SellTicker.class){
                    if (tickers > 0) {
                        System.out.println(Thread.currentThread().getName() + "正在出售票" + tickers + "张票");
                        tickers--;
                    }
                }
            }else {
//                try {
//                    Thread.sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                synchronized (obj) {
//                    if (tickers > 0) {
//                        System.out.println(Thread.currentThread().getName() + "正在出售票" + tickers + "张票");
//                        tickers--;
//                    }
//                }
                sellTicker();
            }
            x++;
        }
    }

//    private void sellTicker() {
//        try {
//            Thread.sleep(100);
//        } catch (InterruptedException e) {
//                    e.printStackTrace();
//        }
//        synchronized (obj) {
//            if (tickers > 0) {
//                System.out.println(Thread.currentThread().getName() + "正在出售票" + tickers + "张票");
//                tickers--;
//            }
//        }
//    }
//private synchronized void sellTicker() {
//    try {
//        Thread.sleep(100);
//    } catch (InterruptedException e) {
//        e.printStackTrace();
//    }
//        if (tickers > 0) {
//            System.out.println(Thread.currentThread().getName() + "正在出售票" + tickers + "张票");
//            tickers--;
//        }
//    }

    private  static synchronized void sellTicker() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (tickers > 0) {
            System.out.println(Thread.currentThread().getName() + "正在出售票" + tickers + "张票");
            tickers--;
        }
    }
}
/*
        这个程序是一对一下进行执行的，当sellTicker不为静态方法时，使用synchronized,对应的锁为this,
                                      当sellTicker为静态方法时，使用synchronized对应的锁为SellTicker.class.
        
*/

线程安全的类

实现多线程

Lock锁

为了有更清晰的表达如何加锁和释放锁，JDK5之后提供了一个新的锁对象Lock
Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
Lock中提供了获得锁和释放锁的方法

void lock()：获得锁
void unlock(): 释放锁

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
ReetrantLock的构造方法
- ReetrantLock()：创建一个ReetrantLock的实例

package MyThreadDemo;
/*
            void lock()：获得锁
            void unlock(): 释放锁

*/

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

public class SellTrick3 implements Runnable{
    private int tickers = 100;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
                if (tickers > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在出售票" + tickers + "张票");
                    tickers--;
            }
            lock.unlock();
        }
    }
}

实现多线程

码农公寓

相关文章