java多线程使用详解与案例，超详细

java多线程使用

线程lamda表达式方式启动（简单、常用）

new Thread(()->{
            System.out.println("开始了一个线程"+new Date());
        }).start();

java使用多线程的三种方式：

1. 继承Thread类，并重写run方法。
2. 实现Runnable接口，重写run方法
3. 实现Callable<返回值>接口，重写call方法

实例如下

继承Thread

class test extends Thread{
    @Override
    public void run() {
        System.out.println("你好啊");
    }
}

开始启动线程：

new test().start()

实现Runnable

class God implements Runnable{

    @Override
    public void run() {
        while (true)
        {
            System.out.println("上帝守护着你");
        }
    }
}

开始启动线程

new Thread(New God()).start

实现Callable

class dThread implements Callable<Boolean> {
    private String url;
    private String name;
    public dThread(String url,String name)
    {
        this.url=url;
        this.name= name;
    }
    @Override
    public Boolean call() {
        Download d = new Download();
        System.out.println(Thread.currentThread().getName()+"开始下载");
        d.imageDownload(url,name);
        return Thread.currentThread().isAlive();
    }
}

开始启动线程

FutureTask <String>threadTask= new FutureTask<>(new dThread());
new Thread(threadTask).start

开始执行线程只需在线程对象调用start或call方法便开始执行线程

#####################################################

线程池的使用：

我们需要使用ExecutorService对象里面

一个方法newFixedThreadPool(5);，参数为线程存放个数。
实例对象调用execute方法，参数为runable对象
使用案例如下

package cn.xjt.gaoji;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 测试线程池
 * @author xujiangtao
 * @create 2020-08-02-14:42
 */
public class TestPool {     //pool:池子
    public static void main(String[] args) {
        //创建了一个大小为10的线程池
        //固定线程池
        ExecutorService e = Executors.newFixedThreadPool(5);
        //单线程池
        Executors.newSingleThreadExecutor();
        //可缓存线程池
        Executors.newCachedThreadPool();
        //时间周期线程池
        Executors.newScheduledThreadPool(6);
        //工作窃取线程池
        Executors.newWorkStealingPool(2);		//可以指定并行数
        //调用execute方法开启线程
        e.execute(new MyThread());
        //execute:实行
        e.execute(new test());
        e.execute(new MyThread());
        e.execute(new MyThread());
        e.shutdown();                   //关闭线程
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

class test extends Thread{
    @Override
    public void run() {
        System.out.println("你好啊");
    }
}

守护线程：

daemon守护线程会因为用户线程关闭而关闭，默认为用户线程
Thread实例对象setDarmon()方法可以设置是否为守护者线程，默认为false。

守护线程会随着用户线程的结束而结束
java守护线程案例如下：

package cn.xjt.demo03;

/**
 * daemon守护线程会因为用户线程关闭而关闭，默认为用户线程
 * y
 * @author xujiangtao
 * @create 2020-08-01-10:36
 */
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        HandsomeYou handsomeyou = new HandsomeYou();
        Thread thread = new Thread(god);
        thread.setDaemon(true);         //上帝守护线程
        thread.start();
        new Thread(handsomeyou).start();
    }
}
class God implements Runnable{

    @Override
    public void run() {
        while (true)
        {
            System.out.println("上帝守护着你");
        }
    }
}
class HandsomeYou implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("Hello world 你开心的活着");
        }
        System.out.println("======goodbye world========");
    }
}

使用lamda表达式简化java的书写简单化案例如下：

package cn.xjt.demo03;

/**
 * @author xujiangtao
 * @create 2020-07-31-20:10
 */
public class TestLamda {
    //第1步简化->静态内部类
    static class son2 implements Like{

        @Override
        public void lamda() {
            System.out.println("i'm lamda2");
        }
    }
    public static void main(String[] args) {
        Like s = new son1();
        s.lamda();
        s=new son2();
        s.lamda();
        //第2步简化->局部内部类
        class son3 implements Like{

            @Override
            public void lamda() {
                System.out.println("i'm lamda3");
            }
        }
        s=new son3();
        s.lamda();
        //第3步简化->匿名内部类
        s=new Like() {
            @Override
            public void lamda() {
                System.out.println("i'm Lamda4");
            }
        };
        s.lamda();
        //第4步简化->Lamda
        s= ()-> {
                System.out.println("i'm Lamda5");
            };
        s.lamda();
    }
}
//接口类
interface Like{
    void lamda();
}
//正常实现类
class son1 implements Like{

    @Override
    public void lamda() {
        System.out.println("i'm lamda");
    }
}

多线程综合案例

1、买票案例

使用生产者消费者模式。通过缓存区，保证产品数量大于消费数量

package cn.xjt.gaoji;

/**
 * 测试生产者消费者-->利用缓冲区：管程法
 * @author xujiangtao
 * @create 2020-08-01-21:53
 */
//成产者，消费者，产品，缓存区
public class TestPC {
    public static void main(String[] args) {
        Syncontainer syncontainer = new Syncontainer();
        new Productor(syncontainer).start();
        new Consumer(syncontainer).start();

    }
}
//生产者
class Productor extends Thread{
    Syncontainer container;
    public Productor(Syncontainer container)
    {
        this.container=container;
    }
    //生产
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                container.push(new Chicken(i));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("生产了"+(i+1)+"只鸡");
        }
    }
}
//消费者
class Consumer extends  Thread{
    Syncontainer container;
    public Consumer(Syncontainer container)
    {
        this.container=container;
    }
    //消费

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println("消费了->"+container.pop().id+"只鸡");
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//产品
class Chicken{
    int id;
    Chicken(int id)
    {
        this.id=id;
    }
}
//缓冲区
class Syncontainer{
    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    int count =0;
    //生产者放入产品
    public synchronized void push(Chicken chicken) throws InterruptedException {
        //如果容器满了，需要消费者消费
        if(count ==chickens.length)
        {
            this.wait();
        }

        //如果没有满，就需要生产产品放入
        chickens[count] = chicken;
        count++;

        //可以通知消费者了
        this.notifyAll();
    }
    //消费者消费产品
    public synchronized Chicken pop() throws InterruptedException {
        //判断缓冲区是否还有产品
        if(count==0)
        {
            //等待生产者生产，消费者等待
            this.wait();
        }
        count--;
        return chickens[count];
//        this.notifyAll();
        //吃完了，通知生产者生产
    }
}

2、信号灯法，通过标志为解决

package cn.xjt.gaoji;

/**
 * 测试生产者，消费者问题 2：信号灯法
 * 标志位解决
 * @author xujiangtao
 * @create 2020-08-02-13:11
 */
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new actor(tv).start();
        new watcher(tv).start();
    }
}
//生产者->演员
class actor extends Thread{
    TV tv;
    public actor(TV tv)
    {
        this.tv=tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                if(i%2==0)
                {
                    tv.play("抖音:记录美好生活");
                    System.out.println(i);
                }else{
                    tv.play("快乐大本营");
                    System.out.println(i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//消费者->观众
class watcher extends Thread{
    TV tv;
    public watcher(TV tv)
    {
        this.tv=tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                tv.watch("观众");
                System.out.println(i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//产品->Tv
class TV{
    String video;
//    String Watchername;
    boolean flag = true;
    //演员表演，观众等待 T
    //观众观看，演员等待 F
    //表演方法
    public synchronized void play(String vidio) throws InterruptedException {
        //判断如果是true，则表演节目
        if(flag)
        {
            System.out.println("演员表演了->"+vidio);
            Thread.sleep(1000);
            //通知观众观看
            this.notifyAll();   //通知观众观看节目
            this.video=vidio;
            flag=!this.flag;
        }else { //否则，等待观众观看
            this.wait();
        }
    }
    public synchronized void watch(String watchername) throws InterruptedException {
        //判断如果为flase，则观众观看节目
        if(!flag)
        {
            System.out.println(watchername+"观看了"+video);
            Thread.sleep(1000);
            this.notifyAll();
            flag=!flag;
        }else{  //否则等待，直到表演者表演完，再继续观看
            this.wait();
        }
    }
}

3、买票与卖票。

使用加锁。保证票的数量在有的情况才可以出售，解决并发问题demo。

package cn.xjt.gaoji;


import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 买票系统会出现不安全
 * 需要加上锁
 * 通过ReenTrantlock对象进行加锁，解锁
 * private final ReentrantLock locks = new ReentrantLock();
 * @author xujiangtao
 * @create 2020-08-01-16:59
 */
public class TestReentrantLock {
    public static void main(String[] args) {
        buyticket person = new buyticket();
        Thread t = new Thread(person);
        t.start();
        t=new Thread(person);
        t.start();
        t= new Thread(person);
        t.start();
    }

}
//一个卖票的类
class buyticket implements Runnable{
    //Reentrantlock:可重进锁
    private final ReentrantLock locks = new ReentrantLock();
    //票数
    int ticket =10;
    @Override
    //重写的方法
    public void run() {
        while (true)
        {
            try {
                //开启一个锁        开启一个锁最好放在try语句
                locks.lock();
                if(ticket>0)
                {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticket--);
                }
                else
                {
                    System.out.println("你买的票已经被购完");
                    break;
                }
            }finally {
                //关闭一个锁
                locks.unlock();
            }
        }
    }
}