0
点赞
收藏
分享

微信扫一扫

多线程讲解

小亦同学321 2022-04-03 阅读 46
javajava-ee

多线程的了解

什么是多线程：
1是指从软件或者硬件上实现多个线程并发之执行的技术
2 具有多线程能力的计算机因有硬件支持而能够同一时间执行的多个线程，提升能力
举个例子：（多线程就是同时执行多个应用程序）
一个小伙在玩电脑，左手玩着电脑右手一会按几下鼠标一会拿一下烟一会拿一下可乐因为右手的手速特别快在别人看来就是在同时在做三件事情我们的右手就相当于于是CPU我们右手做的那些操作相当于是在执行的程序，我们右手做的操作就相当于是多线程的操作。

并发和并行的区别:

并行: 在同一时刻，有多个指令在多个CPU上交替执行
并发：
在同一时刻有多个指令在单个CPU上同时执行

进程和线程的区别：

进程就是正在运行的软件：进程包含以下三点

  1. 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度和调度的独立单位

  2. 动态性:进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的

  3. 并发性:任何进程都可以同其他进程一起并发执行
    线程： 是进程中的单个顺序控制流，是一条执行路径（一个进程包含多个线程,一个进程里有多个线程在执行，一个进程里必须有一个线程）

  4. 单线程：见名知意单进程就是一个进程里面只有一个线程执行的路径

  5. 多线程：一个进程有多个线程在执行

创建线程的方式

  1. 第一种定义一个类继承Thread类重写run方法
    注意： 直接执行run方法体代码不是开启线程，start才是开启线程的方法 ，而我们开启线程是执行run方法体重的代码
public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        //开启一条线程
        my1.start();
        my2.start();
    }
}

2 第二种： 实现多线程的方式
定义一个MyRunnable类实现Runnable接口
在MyRunnable类中重写run()方法
创建MyRunnable类中的对象
创建Thread类对象，将MyRunnable对象作为构造函数方法的参数
启动线程

/**
 * @Date: 2022/4/1 15:49
 * @Author: si.ma.zong.ze
 */
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }

/**
 * @Date: 2022/4/1 15:54
 * @Author: si.ma.zong.ze
 */
public class Demo {
    public static void main(String[] args) {
        MyRunnable myRunnable= new MyRunnable();
        Thread t= new Thread(myRunnable);
        t.start();
    }
  }

3 第三种实现方式 第三种实现方式是有返回值的
定义一个MyCallable实现Callable接口
在MyCallable类中重写call()方法
创建MyCallable类对象
创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法参数
创建Thread类的对象，把FutureTask对象对象作为构造方法的参数
启动线程

/**
 * @Date: 2022/4/1 16:11
 * @Author: si.ma.zong.ze
 */
public class MyCallable implements Callable<Object> {
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("追求女孩"+i);
        }
        return "答应了";
    }
/**
 * @Date: 2022/4/1 16:12
 * @Author: si.ma.zong.ze
 */
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable= new MyCallable();

        FutureTask<String> futureTask= new FutureTask(myCallable);

        Thread thread= new Thread(futureTask);

        thread.start();
        String s = futureTask.get();
        System.out.println(s);
    }

线程方法：

1设置别名
setName(String name) 将此线程的名称更改为等于参数name
getName() 返回此线程的名称
currentThread() 返回对当前正在执行的线程对象的引用

public class MyThread extends Thread {
   
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

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

        //Thread(String name)
        MyThread my1 = new MyThread("高铁");
        MyThread my2 = new MyThread("飞机");

        my1.start();
        my2.start();

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

2线程优先级
getPriority() 返回此线程的优先级
**setPriority(int newPriority)**更改此线程的优先级 线程默认优先级是5；线程优先级的范围是：1-10

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

        //public final void setPriority(int newPriority)：更改此线程的优先级
//        tp1.setPriority(10000); //IllegalArgumentException
        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();
    }
}

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

  • sleep演示
public class ThreadSleep extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();

        ts1.setName("曹操");
        ts2.setName("刘备");
        ts3.setName("孙权");

        ts1.start();
        ts2.start();
        ts3.start();
    }
}
  • join演示
public class ThreadJoin extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}
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 {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
}
  • Daemon演示
public class ThreadDaemon extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}
public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();

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

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

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

        td1.start();
        td2.start();

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

4 线程的生命周期
新建->就绪->阻塞->等待->计时等待->结束
生命周期
5多线程案例
卖票的案例当天有100张票我们分为3个窗口卖票每个窗口相当于一个线程,直到给票卖完为止。
代码演示：

public class SellTicket implements Runnable {
    private int tickets = 100;
    //在SellTicket类中重写run()方法实现卖票，代码步骤如下
    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                tickets--;
            }
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        //创建SellTicket类的对象
        SellTicket st = new SellTicket();

        //创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

卖票可能出现的问题：1.会出现一张票卖出去多次2.会出现负数票(如果出现下面的情况是不是很恐怖了)
出现问题的原因： 线程执行的随机性导致的
代码演示：

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

    @Override
    public void run() {
        //相同的票出现了多次
//        while (true) {
//            //tickets = 100;
//            //t1,t2,t3
//            //假设t1线程抢到CPU的执行权
//            if (tickets > 0) {
//                //通过sleep()方法来模拟出票时间
//                try {
//                    Thread.sleep(100);
//                    //t1线程休息100毫秒
//                    //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
//                    //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                //假设线程按照顺序醒过来
//                //t1抢到CPU的执行权，在控制台输出：窗口1正在出售第100张票
//                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//                //t2抢到CPU的执行权，在控制台输出：窗口2正在出售第100张票
//                //t3抢到CPU的执行权，在控制台输出：窗口3正在出售第100张票
//                tickets--;
//                //如果这三个线程还是按照顺序来，这里就执行了3次--的操作，最终票就变成了97
//            }
//        }

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

线程安全问题解决

方式一 ~~~~~~~~~~~~
现在我们来讲讲线程的的安全问题如何解决线程安全问题： 首先我们先知道线程在什么情况下会发生线程安全问题
1.是多线程环境
2.有共享数据
3.有多条语句操作共享数据
在这种情况下回发生线程安全不问题，这个时候我们就给线程加锁给锁起来每次保证只有一条线程在操作数据就不会出现线程安全问题了

解决方案：
synchronized同步代码块格式解决：synchronized就相当于给代码加锁了，任意对象就可以看成是一把锁
好处：解决了多线程的数据安全问题
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
代码演示：

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            //tickets = 100;
            //t1,t2,t3
            //假设t1抢到了CPU的执行权
            //假设t2抢到了CPU的执行权
            synchronized (obj) {
                //t1进来后，就会把这段代码给锁起来
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                        //t1休息100毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //窗口1正在出售第100张票
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--; //tickets = 99;
                }
            }
            //t1出来了，这段代码的锁就被释放了
        }
    }
}

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

        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 返回值类型 方法名(方法参数) { 
	方法体；
}

代码演示

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

    @Override
    public void run() {
        while (true) {
			sellTicket()；
    	}
    }

//  静态同步方法
    private static synchronized void sellTicket() {
        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
            tickets--;
        }
    }
}

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

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

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

第二种锁
look锁虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
代码演示：

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

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();

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

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

线程安全的类

StringBuffer
线程安全，可变的字符序列
从版本JDK 5开始，被StringBuilder 替代。 通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步
Vector
从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Vector被同步。 如果不需要线程安全的实现，建议使用ArrayList代替Vector
Hashtable
该类实现了一个哈希表，它将键映射到值。 任何非null对象都可以用作键或者值实现了Map接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Hashtable被同步。 如果不需要线程安全的实现，建议使用HashMap代替Hashtable

生产者和消费者模式概述

生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。
所谓生产者消费者问题，实际上主要是包含了两类线程：
一类是生产者线程用于生产数据
一类是消费者线程用于消费数据
为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为
生产者消费者流程
代码实现:

public class Box {
    //定义一个成员变量，表示第x瓶奶
    private int milk;
    //定义一个成员变量，表示奶箱的状态
    private boolean state = false;

    //提供存储牛奶和获取牛奶的操作
    public synchronized void put(int milk) {
        //如果有牛奶，等待消费
        if(state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果没有牛奶，就生产牛奶
        this.milk = milk;
        System.out.println("送奶工将第" + this.milk + "瓶奶放入奶箱");

        //生产完毕之后，修改奶箱状态
        state = true;

        //唤醒其他等待的线程
        notifyAll();
    }

    public synchronized void get() {
        //如果没有牛奶，等待生产
        if(!state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果有牛奶，就消费牛奶
        System.out.println("用户拿到第" + this.milk + "瓶奶");

        //消费完毕之后，修改奶箱状态
        state = false;

        //唤醒其他等待的线程
        notifyAll();
    }
}

public class Producer implements Runnable {
    private Box b;

    public Producer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        for(int i=1; i<=30; i++) {
            b.put(i);
        }
    }
}

public class Customer implements Runnable {
    private Box b;

    public Customer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        while (true) {
            b.get();
        }
    }
}

public class BoxDemo {
    public static void main(String[] args) {
        //创建奶箱对象，这是共享数据区域
        Box b = new Box();

        //创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
        Producer p = new Producer(b);
        //创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
        Customer c = new Customer(b);

        //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);

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

相关推荐

多线程讲解（详解）

golang开发语言后端

【Python多线程】的进阶讲解

算法数据结构

基础讲解多线程，并发并行，线程与进程

java

多线程讲解+ Python thread实战操作

python开发语言多线程子线程主线程JavaScript前端开发

python多线程----------主线程,子线程,任务讲解----拿下就是胜利

开发语言python

Python爬虫基础讲解（十六）：多线程简介

python多线程编程语言多进程多任务虚拟化云计算

java多线程——多线程概述

java

Linux 多线程 （ 多线程概念 ）

mysql

java多线程-实现多线程（二）

C#封装服务Windows服务

JAVA多线程九：多线程同步

多线程线程安全volatilelocak加锁线程同步Java后端开发
0 条评论