java基础知识--传统多线程技术

最新推荐文章于 2024-03-10 23:38:03 发布

Jivan2233

最新推荐文章于 2024-03-10 23:38:03 发布

阅读量357

点赞数 2

分类专栏： Java基础知识 JAVA SE基础知识文章标签： java 多线程

本文链接：https://blog.csdn.net/q982151756/article/details/79227568

版权

Java基础知识同时被 2 个专栏收录

21 篇文章 3 订阅

订阅专栏

JAVA SE基础知识

21 篇文章 6 订阅

订阅专栏

本人的GitHub：戳我一下

一、进程和线程

进程：是一个正在执行的程序，每一个进程都有一个独立的内存空间。
线程：是进程中的一个独立的控制单元，一个进程中所有的线程共用一个内存空间。
关系：一个进程至少包含一个线程，线程是进程的一部分。

二、创建一个线程

创建线程有两种方法：
1、继承Thread类，并覆写run()方法：

class Demo extends Thread {
    public void run() {
        System.out.println("haha");
    }
}
class ThreadDemo {
    public static void main(String[] args) {
        Demo d = new Demo();//创建好一个线程
        d.start();//启动线程
    }
}

2、实现Runnable接口：

class Demo implements Runnable {
    public void run() {
        System.out.println("haha");
    }
}
class RunnableDemo {
    public static void main(String[] args) {
        Demo d = new Demo();
        new Thread(d).start();
    }
}

三、线程的四种状态及状态间的转换

1、被创建：线程刚被创建，还没有start()
2、运行：线程已经start()，且正在运行
3、阻塞：线程已经start()，但是没有运行资格，等待别的线程运行，当别的线程运行时间结束，就可以运行
4、死亡：该线程死亡，无法运行。
5、冻结：线程通过wait() sleep()等方法放弃了执行的资格，等待被唤醒。
这里写图片描述

四、线程安全问题

首先先看个示例：这是一个模拟卖票的小程序，我们可以发现代码中只有100张票，如果线程安全，那么4个线程一共应该卖出100张票，并且1~100各一张

public class TickeDemo {
    public static void main(String[] args) throws InterruptedException {
        Ticket t = new Ticket();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class Ticket implements Runnable {
    private static int tick = 100;
    public void run() {
        while(tick > 0) {
            try {
                if(tick > 0)
                    System.out.println(Thread.currentThread().getName() + "..." + tick--);
                else break;
                    Thread.sleep(100);

            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

运行结果部分截取：
这里写图片描述

运行结果分析：
发现出现了一张票被卖多次的情况出现，出现这种情况的原因是当一个线程在操作tick这个共享数据时，突然被阻塞，然后另一个线程进来操作tick导致出现共享数据的错误。

解决办法：
对共享数据操作的过程中，只能让一个线程操作共享数据，只有该线程操作完成后，下一个线程才能继续执行。java对线程安全问题提供了解决的方法，就是同步代码块：

synchronized(对象) {
    //操作共享数据的代码块
}

对象如同锁，只有持有锁的线程才能执行同步代码块中的代码

解决问题后的代码：

public class TickeDemo {
    public static void main(String[] args) throws InterruptedException {
        Ticket t = new Ticket();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class Ticket implements Runnable {
    private static int tick = 100;
    Object obj = new Object();
    public void run() {
        while(true) {
            synchronized(obj) {
                if(tick > 0)
                    System.out.println(Thread.currentThread().getName() + "..." + tick--);
                else break;
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }   
    }
}

同步的前提：
1、必须有两个或两个以上的线程
2、必须使用的是同一个锁

如何判断代码是否需要同步：
1、明确那些代码是多线程运行代码
2、明确共享数据
3、明确多线程代码中那些是操作共享数据的

synchronized可以作为修饰符修饰一个函数，使该函数具备同步性，例如：

public synchronized void function() {
        sum += 1;
        System.out.println(sum);
}

其中，sum是共享数据，这个函数是同步的，线程安全。

四、锁

上面提到的synchronized(对象)中的对象就是锁，这个锁可以是任何对象，而用synchronized修饰的函数使用的是this这个对象来做锁，如果这个函数是静态的，那么它的锁是对象名.Class对象。
如果一个共享数据在不同的操作中使用了不同的锁，那么该代码就不是线程安全的，举个例子：还是卖票的例子，不过代码有些变化，这次增加了一个show()函数，两个线程用了不同的锁，其中if语句中使用的是obj这个对象锁，而show()函数使用的是this这个对象锁

public class TickeDemo {
    public static void main(String[] args) throws InterruptedException {
        Ticket t = new Ticket();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.start();
        Thread.sleep(100);
        t.flag = false;
        t2.start();
    }
}

class Ticket implements Runnable {
    private static int tick = 100;
    boolean flag = true;
    Object obj = new Object();
    public void run() {
        if(flag) {
            while(true) {
                synchronized(obj) {
                    if(tick > 0)
                        System.out.println(Thread.currentThread().getName() + "...code..." + tick--);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }   
        }
        else {
            while(true) {
                show();
            }
        }
    }
    public synchronized void show() {
        if(tick > 0)
            System.out.println(Thread.currentThread().getName() + "...show...." + tick--);
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果截取:
这里写图片描述
结果分析：
可以看出，代码并不是线程安全的，如果想要使代码变成安全的，那么只需要把synchronized(obj)换成synchronized(this)，就可以了。

五、线程间的通信——等待唤醒机制

1、我们通过看java文档可以发现Object类中有wait() notify() notifyAll()三种方法，我们就是通过这三个方法来实现线程间的通信操作。
2、wait()方法可以让该线程进入冻结状态，在没被唤醒期间该线程不会运行。
3、notify()方法可以随机唤醒一个线程。
notifyAll()方法可以唤醒所有被冻结的线程。
4、注意这里的三个方法都是通过锁来操作的，假如我们有一个Object对象锁叫obj，有甲和乙两个线程，这里我们通过obj.wait()将甲线程冻结，然后我们可以用obj.notifyAll()将甲线程唤醒，notifyAll()只能唤醒同一个锁冻结的线程，如果还有一个锁this，那么我们是不可以用this.notifyAll()来唤醒被obj冻结的线程的。
这里可以通过生产者消费者的例子来理解，下面是代码：


public class ProducerConsumerDemo {
    public static void main(String[] args) {
        Resource r = new Resource();
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        //注意这里t1 t2 是生产者，t3 t4是消费者
    }
}
class Resource {
    private String name;
    private int count = 1;
    private boolean flag = false;
    public synchronized void set(String name) {
        while(flag) {
            try {
                this.wait();
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
        this.name = name + "---" + count++;
        System.out.println(Thread.currentThread().getName()+"----------生产者"+this.name);
        flag = true;
        this.notifyAll();
    }
    public synchronized void out() {
        while(!flag) {
            try {
                this.wait();
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
        System.out.println(Thread.currentThread().getName()+"--消费者"+this.name);
        flag = false;
        this.notifyAll();
    }
}
class Producer implements Runnable {
    private Resource res;
    Producer(Resource res) {
        this.res = res;
    }
    public void run() {
        while(true) {
            res.set("+商品+");
            try {
                Thread.sleep(100);
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    }
}
class Consumer implements Runnable {
    private Resource res;
    Consumer(Resource res) {
        this.res = res;
    }
    public void run() {
        while(true) {
            res.out();
            try {
                Thread.sleep(100);
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    }
}

六、其他

1、停止线程

停止线程只有一种方法，就是run方法的代码结束，我们一般把多线程用于循环中，我们通过控制循环就可以控制多线程，这里需要注意一种情况，那就是如果主线程已经结束，但是其他的线程都冻结了，那么程序就挂起了，我们只能通过手动关闭程序，这种情况无疑是非常糟糕的，比如下面这段代码，运行之后就会发现，当主线程结束后，程序没有结束，就是因为其他的两个线程都冻结了，这里我们就需要考虑怎么将冻结的程序唤醒。

public class StopThreadDemo {
    public static void main(String[] args) {
        StopThread st = new StopThread();
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        t1.start();
        t2.start();
        for(int i=0;i<60;i++) {
            System.out.println(Thread.currentThread().getName() + "--------main" + i);
        }
        st.changeFlag();

    }
}
class StopThread implements Runnable {
    private boolean flag = true;
    public synchronized void run() {
        while(flag) {
            try {
                this.wait();
            } catch (Exception e) {
                System.out.println(Thread.currentThread().getName() + "--------interrupt");
            }
            System.out.println(Thread.currentThread().getName() + "--------run");
        }
    }
    public void changeFlag() {
        this.flag = false;
    }
}

我们可以用interrupt()方法来处理这种情况，这个方法可以让冻结中的线程强制的苏醒，注意interrupt()方法会报一个InterruptedException错误，上面的例子就可以改为：

public class StopThreadDemo {
    public static void main(String[] args) {
        StopThread st = new StopThread();
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        t1.start();
        t2.start();
        for(int i=0;i<60;i++) {
            System.out.println(Thread.currentThread().getName() + "--------main" + i);
        }
        st.changeFlag();
        t1.interrupt();
        t2.interrupt();
        System.out.println("over");

    }
}
class StopThread implements Runnable {
    private boolean flag = true;
    public synchronized void run() {
        while(flag) {
            try {
                this.wait();
            } catch (Exception e) {
                System.out.println(Thread.currentThread().getName() + "--------interrupt");
            }
            System.out.println(Thread.currentThread().getName() + "--------run");
        }
    }
    public void changeFlag() {
        this.flag = false;
    }
}

运行结果截图
这里写图片描述

2、守护线程

我们可以通过setDaemo()方法来将一个线程设置为守护线程，守护线程的特性是：当非守护线程都停止运行后，守护线程自动停止。

3、`join`方法

join方法可以让当前的线程退出运行，直到调用join方法的线程停止，才继续运行，这里举个例子，加入有甲乙丙三个线程，其中甲正在运行，这时，乙调用了join方法，那么甲就会停止运行，然后乙和丙轮流执行，直到乙运行结束，甲才能运行，此时如果丙没有运行完，就是甲和丙轮流执行。

4、优先级和`yield`方法

这里的优先级很好理解，就是那个线程的优先级高，cpu就优先运行那么线程，可以通过setPriority()方法来设置优先级，注意优先级只有（1~10）默认是“5”。
yield方法的功能是停止当前的线程，转去执行其他的线程。

Jivan2233

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
3
评论
java基础知识--传统多线程技术

本人的GitHub：戳我一下一、进程和线程进程：是一个正在执行的程序，每一个进程都有一个独立的内存空间。线程：是进程中的一个独立的控制单元，一个进程中所有的线程共用一个内存空间。关系：一个进程至少包含一个线程，线程是进程的一部分。二、创建一个线程创建线程有两种方法： 1、继承Thread类，并覆写run()方法：class Demo extends Thr...
复制链接

扫一扫