Java多线程基础

最新推荐文章于 2024-11-03 11:01:20 发布

Dev-Y

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量222

点赞数

分类专栏： java 文章标签： java 多线程编程语言

本文链接：https://blog.csdn.net/yuwenhao07/article/details/68065544

版权

java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、杂谈

java作为一种网络语言对于多线程的支持，还是十分完善的。在此不是为了多么深入的去了解java的多线程技术，只是为了对于多线程有一定的了解，并且能够有一些简单的应用。因为多线程这个话题并不是一言两语能够说的清楚的。如果我能够搞清楚了，就再写几篇详解吧。

二、概述

并发技术一直是编程语言里面的一种高级技术。它意味着通过编程语言来控制多个处理器来处理事务，使得整个任务完成的更加的高校。而并发技术也主要是为了解决两个问题：速度，事务管理。

首先讲速度，再这里有一个概念大家需要知道，就是多线程的解决方案，肯定比单线程顺序执行的时间消耗要大。原因是上下文切换问题（即在不同的任务之间来回切换是需要消耗时间）而且并发技术在单核处理器中，其实就是时间片的轮转，将任务分成很多小块，然后依次获得CPU的使用权，执行一个时间片后放弃，给另一个任务。让多个任务看起来是同时执行的。那为何还需要多线程技术呢？因为阻塞问题，在单线程中，一旦出现阻塞整个程序将停止运行，而多线程中，只有阻塞线程会停止进入等待资源释放，其他的线程会继续执行，这样换来的时间，使程序运行的更快更稳定。

其次是事务管理问题，这个问题再用户交互层面十分常见。比如一个退出按钮。你需要在执行任何操作完成后检测用户的输入情况，才能给予用户适当的响应。但是这样做是不合理的，因为这样不但增加的模块代码的量，也会使得业务逻辑不清晰明确。所以如果有一个线程一直在运行着，不断的检测用户的输入，也许该线程会长时间阻塞等待，但是一旦有输入，就会立马进行相应。

进程与线程是两个概念，进行会被操作系统分配独立的运行空间，以及CPU，且进程之间无法进行直接的信息交互。就好像是运行在两台计算机上的程序一样，互相之间没有干扰，但是还是会有进程通讯的方法，这里就不介绍了。而线程则不一样，一个进程中可以有多个线程，可以理解为程序的多个分支，会被分给时间片，使线程之间保持同步运行。我的理解是进程实现了并行，线程实现了并发。

二、使用说明

一、创建

java中线程的创建有两种方法：
1. 直接继承Thread类
2. 实现Runnable接口

两种方法大同小异，其实Thread也是实现了Runnable接口的。先讲第一种方法：
1. 继承Thread类
2. 重写run方法
3. 在主线程中，实例化子线程对象，调用start方法，启动子线程，调用相应的run方法
一个线程只能执行一次start方法，不能直接调用run方法来启动一个线程，因为run只是一个普通方法。

Thread常用方法：

方法	作用
run()	实现子线程所需操作
start()	启动线程，并执行相应的run方法
currentThread()	静态，获取当前线程实例
getName()	获取线程名字
setName()	设置线程名字
yield()	显示释放线程执行权
join()	使另一个线程先执行，等其执行完毕再执行本线程
isAlive()	判断当前线程是否存活
sleep()	显示让当前线程睡眠
getPriority()	返回线程优先级
serPriority()	改变线程优先级

示例：


class SubThread extends Thread{
    public void run(){
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName() +":"+ Thread.currentThread().getPriority()+i);

        }
    }
}


public class TestThread {
    public static void main(String[] args){
        SubThread s = new SubThread();
        s.setPriority(Thread.MAX_PRIORITY);
        s.start();
        s.setName("线程1");

        Thread.currentThread().setName("主线程");
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName() +":"+ Thread.currentThread().getPriority()+i);
        }
    }

}

第二种方法创建线程
- 子线程继承Runnable接口，并实现其run方法
- 利用Thread构造器传入实现Runnable接口的子线程对象，得到完整的子线程
- 调用start方法开启线程

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


public class TestThread1 {
    public static void main(String[] args){
        PrintNum1 p = new PrintNum1();
        Thread t1= new Thread(p);
        t1.start();
    }
}

两种方法比较：实现接口的方法要优于继承的方法，避免了单继承的局限性，有共享数据时更优化。
线程的生命周期：
这里写图片描述

该图片很好的展示了整个线程的生命周期：新建，就绪，运行，阻塞，死亡。不同的方法导致线程进入不同的阶段。

二、线程安全问题

线程的安全问题在于，多个线程再访问同一个数据的时候，会产生数据脏读的现象。即A线程在在操作了x变量后没有及时的进行后面的操作而挂起或者sleep了，B线程在访问x变量的时候，不知道A已经执行了操作，就会再执行一遍，使得x的数据出现问题。即由于一个线程在操作共享数据的过程中，未执行完的情况，另一个线程参与进来，导致共享数据存在安全问题。

解决方案：同步机制
方式一：同步代码块（锁）

synchronized（同步监视器）｛
    同步代码块（共享数据）
｝

将共享数据放在同步代码块内，只有持有同步监视器的线程才可以执行下面的操作。同步监视器：由一个对象充当，一般为每个线程都只有同一个对象充当锁。

示例：

class window extends Thread{
    static int ticket = 100;
    static Object obj = new Object();
    public void run(){
        while(true){
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.currentThread().sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "" + ticket--);
                }
            }
        }
    }
}


public class TestWindow {
    public static void main(String[] args){
        window w1 = new window();
        window w2 = new window();
        window w3 = new window();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }

}

sleep（）在该段代码中，使线程安全问题更明显，每个Thread中都只有一个object对象充当同步监视器，即谁获得锁，谁可以操作共享数据，所以object是static的。

方式二：同步方法（用synchronized修饰方法，则该方法为同步代码）

示例：

class window extends Thread{
    static int ticket = 100;
    static Object obj = new Object();
    public void run(){
        while(true){
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.currentThread().sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "" + ticket--);
                }
            }
        }
    }
}


public class TestWindow {
    public static void main(String[] args){
        window w1 = new window();
        window w2 = new window();
        window w3 = new window();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }

}

在使用同步锁的时候一定要注意死锁问题即，不同线程分别占用对方需要的同步资源不放弃

三、线程通信

线程通讯主要依赖以下三个方法，wait() , notify() , notifyAll(),且三个方法只能在同步代码块中使用。

方法	作用
wait（）	打开同步锁让別的线程，来操作共享数据，自己排队等候
notify（）	唤醒正在排队的中优先级最高的
notifyAll（）	唤醒所有排队的线程

wait的线程必须要用notify唤醒

示例：


class Account {
    double balance;
    public Account(){

    }

    public synchronized void deposit(double amt){
        notify();
        balance += amt;
        try {
            Thread.currentThread().sleep(10);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+":"+balance);
        try {
            wait();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

class Customer extends Thread{
    Account account;

    public Customer(Account account){
        this.account = account;
    }

    public void run(){
        for(int i = 0 ; i < 3 ; i++)
        account.deposit(1000);
    }
}

public class TestBank {
    public static void main(String[] args) {
        Account acc = new Account();
        Customer c1 = new Customer(acc);
        Customer c2 = new Customer(acc);

        c1.setName("用户1");
        c2.setName("用户2");

        c1.start();
        c2.start();
    }
}

最后练习：
生产者消费者模型：

class Clerk {// 店员
    int product;

    public synchronized void addProduct() {
        if(product >= 20){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else{
            product++;
            System.out.println(Thread.currentThread().getName() + "生产第" + product +"产品");
            notifyAll();
        }
    }

    public synchronized void reduceProduct(){
        if(product <= 0){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else{
            System.out.println(Thread.currentThread().getName() + "消费了第" + product +"个产品");
            product--;
            notifyAll();
        }
    }
}

class Producer implements Runnable {// 生产者
    Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    public void run() {
        System.out.println("生产者开始生产");
        while (true) {
            try {
                Thread.currentThread().sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            clerk.addProduct();
        }
    }
}

class Consumer implements Runnable{
    Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }

    public void run(){
        System.out.println("消费者开始消费");
        while(true){
            try {
                Thread.currentThread().sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            clerk.reduceProduct();
        }
    }
}

public class TestProduceConsume {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer p1 = new Producer(clerk);
        Consumer c1 = new Consumer(clerk);

        Thread t1 = new Thread(p1);
        Thread t2 = new Thread(c1);
        Thread t3 = new Thread(p1);

        t1.setName("生产者1号");
        t2.setName("消费者1号");
        t3.setName("生产者2号");

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

    }
}