java-线程-1

最新推荐文章于 2024-07-20 13:04:23 发布

小艾影

最新推荐文章于 2024-07-20 13:04:23 发布

阅读量141

点赞数

分类专栏： Java学习笔记

本文链接：https://blog.csdn.net/qq_41617261/article/details/113604204

版权

Java学习笔记专栏收录该内容

25 篇文章 0 订阅

订阅专栏

实现多线程

继承Thread类，重写run 启动–通过Thread对象.start();
实现Runable接口，重写run，然后new一个Thread对象，把实现Runable类的对象作为构造参数传入启动–通过Thread对象.start();
实现Callable接口，重写call方法（有返回值）

也可以用runable接口的匿名内部类
或者可以使用线程池

程序中同步

同步：程序从上往下有循序执行
异步：程序分别执行，互不影响

阻塞：程序执行到某处被阻塞，需等阻塞任务完成，然后执行响应后才继续往下执行
非阻塞：程序不会在某处被阻塞，不需等阻塞任务完成，而是等阻塞任务完成后通过回调方法执行响应

线程间同步：保证线程安全，即保证数据原子性。

线程安全

多个线程共享同一个全局变量，做写时，可能受到其他线程干扰，导致数据有问题。读时，不会产生影响。

线程之间同步即：保证数据的原子性
- synchronized–自动挡
- lock–手动档 jdk1.5并发包

synchronized 锁

最好两个线程以上才加锁，一个线程也加锁降低了性能，因为一个线程不会发生安全问题，加锁后还要先判断然后才能操作
谁先拿到锁谁先操作，一个线程操作另一线程无法操作即保证只有一个线程进行执行操作
多个线程想同步，必须用同一把锁

什么地方需要加锁?

包裹需要操作共享数据的代码块

锁什么时候释放？

代码执行完毕或程序抛出异常

缺点：效率非常低
弊端：多个线程需要判断锁，较为消耗资源，即抢锁的资源

同步函数使用的是this锁

怎么证明同步函数使用this锁?

两个线程实现同步，一个用this锁同步代码块，一个用同步函数

一个线程使用同步函数,另一个线程使用同步代码块(非this)则不能够同步
静态同步函数不是用this锁

一个变量被static修饰的话存放在永久区，当class文件被加载的时候就会初始化
静态同步函数使用的是该文件字节码锁

死锁问题

同步中嵌套同步，无法释放。一直等待，变为死锁

package com.xiaoai.thread;

/**
 *
 * 线程问题
 */
public class T1_si implements Runnable{

    public static Object oj = new Object();
    public int trainlCount = 100;
    public boolean flag = true;

    @Override
    public void run() {
        if (flag){
            while (true){
                synchronized (oj){  //xc-1 到这里得到了oj锁，要进入sale()需要拿到this锁
                    sale();
                }
            }
        }else {
            while (true){
                sale();
            }
        }
    }

    public synchronized  void sale(){   //同时，xc-2 到这里得到了this锁，要执行需要拿到oj，由于oj锁被xc-1拿去了所以两个都在等，即产生了死锁
        synchronized (oj){
            if (trainlCount>0){
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+",出售第"+(100-trainlCount+1)+"张票");
                trainlCount--;
            }
        }
    }
    
    public static void main(String[] args){
        T1_si myt1 = new T1_si();
        Thread t1 = new Thread(myt1,"xc-1");
        Thread t2 = new Thread(myt1,"xc-2");

        t1.start();
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myt1.flag = false;
        t2.start();
    }
}

多线程三大特性
- 原子性一致性–保证线程安全问题
- 可见性 java内存模型
- 有序性 join、wait、notfy

java内存模型 ----线程安全问题的产生

即可见性：决定了一个线程与另一个线程是否可见。即数据的修改是否能被另一个线程知道

主内存：主要存放共享的全局变量
线程私有本地内存：本地线程私有变量

每个线程都有一个私有本地内存，如果某一本地内存修改共享变量后，主内存没有及时通知到其他线程的私有本地内存，则可能发生数据不一致(同步)的问题
volatile关键字修饰共享变量，其他线程修改共享变量时可以强制刷新到主内存，然后主内存及时通知其他线程，以此实现线程可见性

package com.xiaoai.thread;

import java.lang.reflect.Type;
import java.security.PublicKey;

class ThreadVolatileDome extends Thread{
    public volatile boolean flag = true;
    @Override
    public void run() {
        System.out.println("子线程开始执行");
        while (flag){ }
        System.out.println("子线程结束执行");
    }
    public void setFlag(boolean flag){
        this.flag = flag;
    }
}

public class ThreadVolatile {

    public static void main(String[] args) throws InterruptedException {
        ThreadVolatileDome threadVolatileDome = new ThreadVolatileDome();
        threadVolatileDome.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //主线程修改了全局变量，即修改flag变量值，如果不使用volatile修饰flag，则不会及时刷新到主内存，则子线程私有本地内存的flag一直为true，即它不会结束线程
        //通过volatile关键字刷新变量flag值到主内存，主内存及时通知私有本地内存，私有本地内存变量值一修改，线程马上根据变量值进行相关操作
        threadVolatileDome.setFlag(false);
        System.out.println("flag设为false");
        Thread.sleep(100);
        System.out.println(threadVolatileDome.flag);
    }
}

volatile保证线程之间可见性，但不保证原子性

package com.xiaoai.thread;

import java.util.concurrent.atomic.AtomicInteger;

public class VolatileNoAtomic extends Thread {
    //需要10个线程共享count 用static修饰关键字，其存放在静态区，只会存放一次，这样所有线程都会共享了。
//    private volatile static int count = 0;
    //通过AtomicInteger类(原子类，jdk1.5出现)保证线程原子性
    private static AtomicInteger count = new AtomicInteger(0);
    @Override
    public void run() {
        for (int i=0;i<1000;i++){
//            count++;
            count.incrementAndGet();
        }
        //使用volatile修饰，其最后结果可能也不是10000，其只实现线程可见性，不保证线程原子性，因此最后可能不会出现结果10000
//        System.out.println(getName()+","+count)
        //通过原子类保证最后结果得到10000 即线程安全
        System.out.println(getName()+","+count.get());

    }

    public static void main(String[] args){
        //创建10个线程
        VolatileNoAtomic[] volatileNoAtomics = new VolatileNoAtomic[10];

        for (int i=0; i<volatileNoAtomics.length;i++){
            volatileNoAtomics[i] = new VolatileNoAtomic();//创建10个线程
        }
        for (int i=0; i<volatileNoAtomics.length;i++){
            volatileNoAtomics[i].start();
        }
    }
}

多线程间通信

同步：多个线程对同一个资源的相同操作，同步即保证数据安全。
通信：多个线程对同一个资源(共享资源)不同操作。需要进行通信，保证数据安全问题

多个线程使用同一个run方法，通过synchronize锁资源实现同步
多个线程使用的不同的run方法，即生产者和消费者，通过通信来保证安全问题

生产者与消费者模式

多线程通信—生产者和消费者。考虑线程安全问题

生产者：发布资源。如写

消费者：利用资源。如读

package com.xiaoai.thread;

/**
 * 生成者消费者
 */

//资源
class  Res {
    public String userName;
    public String sex;
}

//生产
class  Out extends Thread{
    Res res;
    public Out(Res res){
        this.res = res;
    }
    @Override
    public void run() {
        //写操作 
        int count=0;
        while (true){
            if (count==0){
                res.userName = "xiaoai"; //1--生产线程到这里改变了资源姓名，还未修改性别，同时消费线程直接执行打印了资源信息
                res.sex = "男";
            }else {
                res.userName = "honghong";
                res.sex="女";
            }
            //计算奇数或偶数  使上面写出不同数据
            count = (count+1)%2;
        }
    }
}

//消费
class Input extends Thread{
    Res res;
    public Input(Res res){
       this.res = res;
    }
    @Override
    public void run() {
        while (true){
            //2--消费线程同时运行，打印了userName=xiaoai，但是生成线程还没有修改好性别，此时sex=女，然后这里直接打印了，所以出现了：xiaoai--女
            System.out.println(res.userName+"--"+res.sex);
        }
    }
}
public class OutInputThread {
    public static void main(String[] args){
        Res res = new Res();
        Out out = new Out(res);  //生产线程
        Input input = new Input(res); //消费线程

        out.start();
        input.start();
    }
}

解决1：要使用同一锁用this锁不行，因为不是同一个run即不是同一个this 锁同一个资源(即res)可以，但是有点问题。即不会写一个读一个，或者会重复读取一个相同的数据
解决2：生产一个，消费一个，没有生产即不可消费，消费没完则不可生产

wait():让当前线程从运行状态变为休眠状态即:立即释放锁的资源
notify():让当前线程从休眠状态变为运行状态即：唤醒另一个线程必须是同一个锁的资源才能唤醒
notifyAll():唤醒所有等待中的线程
ps:需要同步才能使用，而且要是同一个锁的资源一般wait()和notify()一起使用 wait和notify只能在synchronized使用

package com.xiaoai.thread;

/**
 * 生成者消费者
 */

//资源 ---包子
class  Res {
    public String pi;  //包子皮
    public String xian; //馅料
    //标志位  true==生产者线程进行等待，消费者可以消费  false==生产者线程进行生产，消费者线程进行等待
    public boolean flag = false;  //有资源=true 没有资源=false
}

//生产者
class  Out extends Thread{
    Res res;
    public Out(Res res){
        this.res = res;
    }

    @Override
    public void run() {
        //生产操作
        int count=0;
        while (true){
            synchronized (res){
                if (res.flag){  //flag==true  有资源，无法生产，所以生产者需要等待
                    try {
                        res.wait(); //表示让当前线程从运行状态变成休眠状态 并且释放锁的资源
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (count==0){
                    res.pi = "薄皮"; //1--生产线程到这里改变了皮，还未修改馅，同时消费线程直接执行打印了资源信息
                    res.xian = "猪肉馅";
                }else {
                    res.pi = "冰皮";
                    res.xian="绿豆馅";
                }
                count = (count+1)%2; //计算奇数或偶数 实现生产不同数据

                System.out.println("生产者生产了-"+res.pi+res.xian+"-包子");
                //----------生产完成，可以消费
                System.out.println("-----------生产了-"+res.pi+res.xian+"-包子，可以消费");
                res.flag = true;//修改标志位，表示写完了，有资源了，提示消费者消费
                res.notify(); // 唤醒消费者线程
            }
        }
    }
}

//消费者
class Input extends Thread{
    Res res;
    public Input(Res res){
       this.res = res;
    }
    @Override
    public void run() {
        //消费操作
        while (true){
            synchronized (res){
                if (!res.flag){  //flag==false 没有资源，无法消费，所以消费者需要等待
                    try {
                        res.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //2--消费线程同时运行，打印了皮=薄皮，但是生成线程还没有修改好馅，此时性别还为绿豆馅，然后这里直接打印了，所以出现了：薄皮绿豆馅包子
                System.out.println("消费者消费了-"+res.pi+res.xian+"-包子");
                //----------消费完了，可以生产
                System.out.println("-----------消费了-"+res.pi+res.xian+"-包子，可以生产");
                System.out.println("------------------------------------------------------\n");
                res.flag = false; //修改标志位，告知消费完了，没有资源了消费了，提醒生产者生产
                res.notify(); //唤醒生产者线程
            }
        }
    }
}
public class OutInputThread {
    public static void main(String[] args){
        Res res = new Res();
        Out out = new Out(res);
        Input input = new Input(res);

        out.start();
        input.start();
    }
}