多线程（上）

最新推荐文章于 2022-12-24 21:37:24 发布

eternity__

最新推荐文章于 2022-12-24 21:37:24 发布

阅读量162

点赞数

文章标签：多线程死锁线程同步

本文链接：https://blog.csdn.net/eternally__/article/details/74031614

版权

线程和进程的区别和联系

进程 : 在操作系统中，每个独立执行的程序都可以称作一个进程。进程是系统分配进行资源分配和调度的一个独立单位。
线程 : 操作系统中的每一个进程中至少有一个线程。线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。
区别:
- 进程:作为资源分配的单位每个进程都有独立的代码和数据空间，进程间的切换就会有较大的开销
- 线程:调度和执行的单位线程可以看成是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器，线程间切换的开销小。

继承Thread类创建多线程

操作步骤:
- 1.继承Thread类
- 2.重写run()方法
- 3.创建线程对象，调用start()方法，启动线程
模拟买票窗口

    public class Ticket extends Thread{
    private int ticket=5;  //5张车票
    @Override
    public void run() {
        for(int i=0;i<10;i++){  //10个人排队买票
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"正在排队买票第"+ticket--+"张票");
                }
            }
        }
    }

public class Test {
    public static void main(String[] args) {
        Ticket t1=new Ticket();
        Ticket t2=new Ticket();
        Ticket t3=new Ticket();
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

实现Runnable接口创建多线程

操作步骤

1.实现Runnable接口
2.重写run方法

3.创建线程对象，调用start()方法，启动线程

public class RunnableThread implements Runnable {
private int ticket = 5;
@Override
public void run() {
    for (int i = 0; i < 10; i++) {
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "正在买第" + ticket-- + "张票");
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
}

public static void main(String[] args) {
RunnableThread runnableThread=new RunnableThread();
Thread t1=new Thread(runnableThread);
Thread t2=new Thread(runnableThread);
Thread t3=new Thread(runnableThread);
t1.start();
t2.start();
t3.start();
}

运行结果:

两种创建多线程的方式的对比分析

继承Thread类创建多线程。通过上面的程序可以看出每张票都被打印了3次，这在现实生活中是不合理的。因为5张票没有被三个线程共享，创建了三个Ticket对象，就相当于创建了三个售票窗口，每个窗口都各拥有5张票。
实现Runnable接口创建多线程。为了解决继承Thread类创建多线程出现的问题，需要使用Runnable接口来解决。Runnable接口创建多线程适合多个线程去处理同一个资源，把线程同程序代码、数据有效的分离。还可以避免由于java单继承带来的局限性。所有大部分应用程序都会用实现Runnable接口来创建多线程

多线程同步

为什么要引入多线程同步
- 通过上面的售票案可以看出一张票被打印多次或者出现0张票甚至负数，这是由于多线程操作操作共享资源ticket时出现了线程安全问题。可以使用同步代码块和同步方法来解决。

使用同步代码块来解决多线程安全问题

public class RunnableThread implements Runnable {
private int ticket = 5;
@Override
public void run() {
    for (int i = 0; i < 10; i++) {
        synchronized (this) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "正在买第" + ticket-- + "张票");
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
    public static void main(String[] args) {
    RunnableThread runnableThread=new RunnableThread();
    Thread t1=new Thread(runnableThread);
    Thread t2=new Thread(runnableThread);
    Thread t3=new Thread(runnableThread);
    t1.start();
    t2.start();
    t3.start();
}

运行结果：

从上面的运行结果可以看出，不会出现一张票被打印多次或者出现0张票甚至负数
同步方法synchronize()和同步代码块可以实现同样的功能，一样可以解决出现一张票被打印多次或者出现0张票甚至负数的问题，这里就不演示了。

死锁问题

两个线程在运行时都在等待对方的锁，这就造成了程序的停滞，这种现象称为死锁。

假设这样一个场景，一个日本人和美国人在一起吃饭，美国人拿了日本人的筷子，日本人拿了美国人的刀叉，两人开始争执，美国人说你先给我刀叉，日本人说你先给我筷子。在这个例子中，美国人和日本人相当于不同的线程，筷子和刀叉就相当于锁，两个线程都在等待对方的锁，这样就造成了程序的停滞，谁到吃不了饭。

public class ThreadLock implements Runnable {
static Object chopsticks = new Object(); // 定义Object类型的chopsticks锁对象
static Object knivesAndForks = new Object(); // 定义Object类型的knivesAndForks锁对象
private boolean flag;

public ThreadLock(boolean flag) {
    this.flag = flag;
}

@Override
public void run() {
    if (flag) {
        while (true) {
            synchronized (chopsticks) { // chopsticks锁对象上的同步代码锁
                System.out.println(Thread.currentThread().getName() + "if----chopsticks");
                synchronized (knivesAndForks) { // knivesAndForks锁对象上的同步代码锁
                    System.out.println(Thread.currentThread().getName() + "if-----knivesAndForks");
                }
            }
        }
    } else {
        while (true) {
            synchronized (knivesAndForks) { // knivesAndForks锁对象上的同步代码锁
                System.out.println(Thread.currentThread().getName() + "else-----knivesAndForks");
                synchronized (chopsticks) { // chopsticks锁对象上的同步代码锁
                    System.out.println(Thread.currentThread().getName() + "else----chopsticks");
                }
            }
        }
    }
}
}
    public static void main(String[] args) {
        ThreadLock threadLock1=new ThreadLock(true);
        ThreadLock threadLock2=new ThreadLock(false);
        new Thread(threadLock1,"日本人").start();  
        new Thread(threadLock2,"美国人").start();
    }

运行结果:

* 从运行结果可以看出日本人线程拥有chopsticks锁，只有获得knivesAndForks锁才能执行完毕，而美国人线程拥有knivesAndForks锁，只有获得chopsticks锁才能执行完毕，两个线程都需要对方所占用的锁，但是都无法释放自己占用的锁，于是线程都处在了挂起状态，造成了死锁现象。

eternity__

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程（上）

线程和进程的区别和联系进程 : 在操作系统中，每个独立执行的程序都可以称作一个进程。进程是系统分配进行资源分配和调度的一个独立单位。线程 : 操作系统中的每一个进程中至少有一个线程。线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。区别: 进程:作为资源分配的单位每个进程都有独立的代码和数据空间，进程间的切换就会有较大的开销线程:调度
复制链接

扫一扫