java并发编程

第一章初识进程并发 1.1 Thread类

并发：虚假的多线程
并行：真实的多线程，速度块一些
进程：资源分配的最小单位
线程：程序运行的最小单位
java，抢占式调度，

主线程,单线程程序
从main开始自上而下依次执行
thread线程类

这时我们有一个需求循环20次打印原来我们学过的方法是

class Person{
    private String name;

    Person(String name) {
        this.name = name;
    }

    public void run(){
        //定义循环20次
        for (int i = 0; i < 21; i++) {
            System.out.println(name+"-->"+i);
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class Demo01mainthread {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        Person p1 = new Person("小岚");
        p1.run();
//        System.out.println(0/0);
        Person p2 = new Person("小冰");
        p2.run();
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
}

这种比较基础的方法

这时我们来试试多进程方法,那么如何来使用多进程呢

我们先来看看他的构造方法

创建多线程程序的第一张方式:创建Thread类的子类
java.lang.Thread类：是描述线程的类，我们要实现多线程，就必须继承Thread类

实现步骤
1.创建一个Thread类的子类
2.在Thread类的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么？)
3.创建Thread类的子类对象
4.调用Thread类的start方法,开启新的线程,执行run方法
void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程,执行其 run 方法）。
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
java程序属于抢占式调度,那个线程的优先级高,那个线程优先执行;同一个优先级,随机选择一个执行

//1.创建一个Thread类的子类
class MyThread extends Thread{
//    2.在Thread类的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么？)


    @Override
    public void run() {
        for (int i = 0; i < 21;i++) {
            System.out.println("run"+i);
        }
    }


}
//main和Mythread抢夺cpu资源
public class Demo02Thread {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        //3.创建Thread类的子类对象
        MyThread My = new MyThread();
        //调用static方法
        //这样会开辟一个新的栈空间
        //多线程之间互不影响
        new MyThread().start();
        My.start();
        //4.调用Thread类的start方法,开启新的线程,执行run方法
        for (int i = 0; i < 21;i++) {
            System.out.println("main"+i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8PIiid8Z-1634368363231)(C:Users86157Desktopjavatestjava基础8并行Demo012_并发与并行.bmp)]

1.2 获取进程名字

获取线程的名称:
1.使用Thread类中的方法getName()
String getName() 返回该线程的名称。
2.可以先获取到当前正在执行的线程,使用线程中的方法getName()获取线程的名称
static Thread currentThread() 返回对当前正在执行的线程对象的引用。

class MyThread1 extends Thread {
    @Override
    public void run() {
        //Thread的方法
        //获取线程的名称
//        String name = getName();
//        System.out.println(name);

//        Thread t = Thread.currentThread();
//        String name = t.getName();
//        System.out.println(name);
        System.out.println(Thread.currentThread().getName());
    }
}

public class Demo03GetName {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());

        //创建Thread类的子类对象
        MyThread1 my = new MyThread1();
        //调用start方法
        my.start();
        new MyThread1().start();
    }
}

输出结果：
main
Thread-0
Thread-1

1.4 设置进程的名字

设置线程的名称:(了解)
1.使用Thread类中的方法setName(名字)
void setName(String name) 改变线程名称，使之与参数 name 相同。
2.创建一个带参数的构造方法,参数传递线程的名称;调用父类的带参构造方法,把线程名称传递给父类,让父类(Thread)给子线程起一个名字
Thread(String name) 分配新的 Thread 对象。

class MyThread2 extends Thread {
    public MyThread2(){}

    public MyThread2(String name){
        super(name);//把线程名称传递给父类,让父类(Thread)给子线程起一个名字
    }
    @Override
    public void run() {
        //获取线程的名称
        System.out.println(Thread.currentThread().getName());
    }
}
public class Demo04SetName {
    public static void main(String[] args) {
        //开启多线程
        MyThread2 a = new MyThread2("小岚");
        a.start();
        new MyThread2("小冰").start();
    }
}

1.5 Sleep方法

在学习python的时候我们学到一个time中的sleep方法

在java中也有sleep

class MyThread2 extends Thread {
    public MyThread2(){}

    public MyThread2(String name){
        super(name);//把线程名称传递给父类,让父类(Thread)给子线程起一个名字
    }
    @Override
    public void run() {
        //获取线程的名称
        System.out.println(Thread.currentThread().getName());
    }
}
public class Demo04SetName {
    public static void main(String[] args) {
        //开启多线程
        MyThread2 a = new MyThread2("小岚");
        a.start();
        new MyThread2("小冰").start();
    }
}

1.6 多线程的第二种创建方式

在java中只能单继承，那么肯定是非常有局限的，有没有一种方法可不继承Thread

创建多线程程序的第二种方式:实现Runnable接口

java.lang.Runnable
Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
java.lang.Thread类的构造方法
Thread(Runnable target) 分配新的 Thread 对象。
Thread(Runnable target, String name) 分配新的 Thread 对象。

步骤：
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法,设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
5.调用Thread类中的start方法,开启新的线程执行run方法
优点：
1.避免单继承的局限性
一个类只能继承一个类
2.增强了程序的扩展性，降低了程序的耦合性
实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
实现类中,重写了run方法:用来设置线程任务
创建Thread类对象,调用start方法:用来开启新线程
方便实现新的线程任务

class RunnableImplier implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
//            currentThread当前线程
//            2.在实现类中重写Runnable接口的run方法,设置线程任务
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}
public class Demo06Runnable {
    public static void main(String[] args) {
//      3.创建一个Runnable接口的实现类对象
        RunnableImplier run = new RunnableImplier();
//      4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread th = new Thread(run);
        for (int i = 0; i < 20; i++) {
//            currentThread当前线程
//            2.在实现类中重写Runnable接口的run方法,设置线程任务
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
        th.setName("小岚");
//      5.调用Thread类中的start方法,开启新的线程执行run方法
        th.start();
    }
}

1.7 匿名内部类实现线程创建

匿名:没有名字
内部类:写在其他类内部的类

匿名内部类作用:简化代码
把子类继承父类,重写父类的方法,创建子类对象合一步完成
把实现类实现类接口,重写接口中的方法,创建实现类对象合成一步完成
匿名内部类的最终产物:子类/实现类对象,而这个类没有名字

格式:
new 父类/接口(){
重复父类/接口中的方法
};

public class Demo07InnerClassThread {
    public static void main(String[] args) {
        //线程的父类
        new Thread(){
            @Override
            //重写run方法
            public void run() {
                for (int i = 0; i < 20 ; i++) {
                    System.out.println(Thread.currentThread().getName() + "黑马-->"+i);
                }
            }
        }.start();
        //接口的
        Thread th = new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 20 ; i++) {
                    System.out.println(Thread.currentThread().getName() + "程序员-->"+i);
                }
            }
        });
        th.start();
    }
}

第二章进程间的共享变量 2.1 发生线程安全问题

在多进程访问一个临界资源的过程中，很容易方式线程安全问题，比如卖票员1卖了票1，卖票员2也卖了票2.

class RunnableImpl implements Runnable{
//    public static void main(String[] args) {
//        System.out.println("-------");
//    }不会执行主函数
    //定义一个多线程的票源
    private int ticket = 100;
    //卖票
    @Override
    public void run() {
        //先判断票是否存在
        while (true) {
            if (ticket > 0 ) {
                System.out.println(Thread.currentThread().getName() + "-->正在卖票"+ticket);
                ticket --;
                //Thread-2-->正在卖票100
                //Thread-2-->正在卖票99
                //Thread-1-->正在卖票100
                //Thread-0-->正在卖票100
            }
        }
    }
}
public class Demo01 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        RunnableImpl run = new RunnableImpl();
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t0.start();
        t1.start();
        t2.start();
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
}

输出结果的行数是远远大于100行的，这个问题我们如何解决呢，我们可给临界资源上锁，

2.2 锁

卖票案例出现了线程安全问题
卖出了不存在的票和重复的票

解决线程安全问题的一种方案:使用同步代码块
格式:
synchronized(锁对象){
可能会出现线程安全问题的代码(访问了共享数据的代码)
}

注意:
1.通过代码块中的锁对象,可以使用任意的对象
2.但是必须保证多个线程使用的锁对象是同一个
3.锁对象作用:
把同步代码块锁住,只让一个线程在同步代码块中执行

class RunnableImpl2 implements Runnable{
    Object obj = new Object();
    //定义一个多线程的票源
    private int ticket = 100;
    //卖票
    @Override
    public void run() {
        //先判断票是否存在
        while (true) {
            //同步代码块
            synchronized (obj) {
                if (ticket > 0 ) {
                    System.out.println(Thread.currentThread().getName() + "-->正在卖票"+ticket);
                    ticket --;
                    //Thread-2-->正在卖票100
                    //Thread-2-->正在卖票99
                    //Thread-1-->正在卖票100
                    //Thread-0-->正在卖票100
                }
            }

        }
    }
}
public class
Demo02solve {
    public static void main(String[] args) {
//        long start = System.currentTimeMillis();
        RunnableImpl2 run = new RunnableImpl2();
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t1.start();
        t2.start();
        t0.start();
//        long end = System.currentTimeMillis();
//        System.out.println(end-start);
    }
}

输出结果整好是100行。

解决线程安全问题的第二种方法：使用同步方法
使用步骤：
1.把访问了共享变量数据的代码抽取出来
2.在方法上添加synchronized修饰符
格式：定义方法的格式
修饰符 synchronized 返回值类型方法名(参数列表){
可能出现线程安全问题的代码
}

class RunableImpl implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
        while (true){
            payTicket();
        }

    }
    
    public synchronized void payTicket(){
        if(ticket>0) {
            System.out.println(this);
            System.out.println(Thread.currentThread().getName() + "正在卖-->" + ticket);
            ticket--;
        }
    }
}
public class Demo02Thread {
    public static void main(String[] args) {
        RunableImpl run = new RunableImpl();
        System.out.println(run);
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        System.out.println(t0);
        System.out.println(t1);
        System.out.println(t2);

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

}

其实说是第二种方法，不过还是同步方法

第三种解决方法：使用Lock锁
Lock接口
他实现了比使用synchronized方法和语句更加广泛的锁定操作
Lock接口中的方法
void lock()
获取锁
void unlock()
释放锁
使用步骤
1.在成员位置创建一个ReentrantLock对象
2.在可能出现安全问题的代码前调用Lock接口的Lock方法获取锁
3.在可能出现安全问题的代码后调用Lock接口的unLock方法释放锁

class RunableImpl2 implements Runnable{
    private static int ticket = 100;
    //成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            l.lock();

            if(ticket>0) {
                try{
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + "正在卖-->" + ticket);
                    ticket--;
                }catch (InterruptedException e){
                    e.printStackTrace();
                }finally {
                    //无论是否出现异常都会释放锁
                    l.unlock();
                }
            }
        }

    }

}
public class Demo04Lock {
    public static void main(String[] args) {
        RunableImpl2 run = new RunableImpl2();
        System.out.println(run);
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        System.out.println(t0);
        System.out.println(t1);
        System.out.println(t2);

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

2.3 生产者消费者问题

首先我们来创建一个生产者类

生产者(包子铺)类:是一个线程类,可以继承Thread
设置线程任务(run):生产包子
对包子的状态进行判断
true:有包子
包子铺调用wait方法进入等待状态
false:没有包子
包子铺生产包子
增加一些趣味性:交替生产两种包子
有两种状态(i%2==0)
包子铺生产好了包子
修改包子的状态为true有
唤醒吃货线程,让吃货线程吃包子

注意:
包子铺线程和包子线程关系–>通信(互斥)
必须同时同步技术保证两个线程只能有一个在执行
锁对象必须保证唯一,可以使用包子对象作为锁对象
包子铺类和吃货的类就需要把包子对象作为参数传递进来
1.需要在成员位置创建一个包子变量
2.使用带参数构造方法,为这个包子变量赋值

public class BaoZiPu extends Thread{
    //1.需要在成员位置创建一个包子变量
    private BaoZi bz;

    //2.使用带参数构造方法,为这个包子变量赋值
    public BaoZiPu(BaoZi bz) {
        this.bz = bz;
    }

    //设置线程任务(run):生产包子
    @Override
    public void run() {
        //定义一个变量
        int count = 0;
        //让包子铺一直生产包子
        while(true){
            //必须同时同步技术保证两个线程只能有一个在执行
            synchronized (bz){
                //对包子的状态进行判断
                if(bz.flag==true){
                    //包子铺调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                //被唤醒之后执行,包子铺生产包子
                //增加一些趣味性:交替生产两种包子
                if(count%2==0){
                    //生产 薄皮三鲜馅包子
                    bz.pi = "薄皮";
                    bz.xian = "三鲜馅";
                }else{
                    //生产 冰皮 牛肉大葱陷
                    bz.pi = "冰皮";
                    bz.xian = "牛肉大葱陷";

                }
                count++;
                System.out.println("包子铺正在生产:"+bz.pi+bz.xian+"包子");
                //生产包子需要3秒钟
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //包子铺生产好了包子
                //修改包子的状态为true有
                bz.flag = true;
                //唤醒吃货线程,让吃货线程吃包子
                bz.notify();
                System.out.println("包子铺已经生产好了:"+bz.pi+bz.xian+"包子,吃货可以开始吃了");
            }
        }
    }
}

接下来我们来创建一个消费者

消费者(吃货)类:是一个线程类,可以继承Thread
设置线程任务(run):吃包子
对包子的状态进行判断
false:没有包子
吃货调用wait方法进入等待状态
true:有包子
吃货吃包子
吃货吃完包子
修改包子的状态为false没有
吃货唤醒包子铺线程,生产包子

public class ChiHuo extends Thread{
    //1.需要在成员位置创建一个包子变量
    private BaoZi bz;

    //2.使用带参数构造方法,为这个包子变量赋值
    public ChiHuo(BaoZi bz) {
        this.bz = bz;
    }
    //设置线程任务(run):吃包子
    @Override
    public void run() {
        //使用死循环,让吃货一直吃包子
        while (true){
            //必须同时同步技术保证两个线程只能有一个在执行
            synchronized (bz){
                //对包子的状态进行判断
                if(bz.flag==false){
                    //吃货调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                //被唤醒之后执行的代码,吃包子
                System.out.println("吃货正在吃:"+bz.pi+bz.xian+"的包子");
                //吃货吃完包子
                //修改包子的状态为false没有
                bz.flag = false;
                //吃货唤醒包子铺线程,生产包子
                bz.notify();
                System.out.println("吃货已经把:"+bz.pi+bz.xian+"的包子吃完了,包子铺开始生产包子");
                System.out.println("----------------------------------------------------");
                System.out.println(Thread.currentThread().getName() + "是这个吃货在吃包子");
            }
        }
    }
}

接下来我们来启动我们的生产者消费者程序

class BaoZi{
    String pi;

    String xian;

    boolean flag = false;
}

public class Demo01WaitAndNotify {
    public static void main(String[] args) {
        //创建包子对象
        BaoZi bz = new BaoZi();
        //创建包子辅线程，开启，生产包子
        new BaoZiPu(bz).start();
        //创建吃货线程，开启，吃包子
        new ChiHuo(bz).start();
    }
}

第三章进程池Pool

容器->集合**(ArrayList,HashSet,linkedList,HashMap)**
线程池：JDK1.5之后提供的在java.util.concurrent.Executors:线程池的工厂类，用来生成线程池
Executors类中的静态方法：
static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
参数:
int nThreads:创建线程池中包含的线程数量
返回值:
ExecutorService接口,返回的是ExecutorService接口的实现类对象,我们可以使用ExecutorService接口接收(面向接口编程)
java.util.concurrent.ExecutorService:线程池接口
用来从线程池中获取线程,调用start方法,执行线程任务
submit(Runnable task) 提交一个 Runnable 任务用于执行
关闭/销毁线程池的方法
void shutdown()
线程池的使用步骤:
1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)

//2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
class RunnableImpl implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "创建了一个新的线程");
    }
}
public class Demo01Pool {
    public static void main(String[] args) {

        //1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());
        //线程池会一直开启，使用完了会自动归还给线程池，线程可以继续使用
        es.submit(new RunnableImpl());
        // 4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
        es.shutdown();
    }
}

下面我们来整活试试在生产者消费者中加入进程池会是什么样子的

class BaoZi{
    String pi;

    String xian;

    boolean flag = false;
}

public class Demo01WaitAndNotify {
    public static void main(String[] args) {
        //创建包子对象
        BaoZi bz = new BaoZi();
        //创建包子辅线程，开启，生产包子
        new BaoZiPu(bz).start();
        //创建吃货线程，开启，吃包子
        new ChiHuo(bz).start();
        //1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
        es.submit(new ChiHuo(bz));

    }
}

我们要的结果出现了，进程池和非进程池的进程争抢包子资源

java并发编程

Java相关栏目本月热门文章