java-多线程

概要:

xmind学习思维导图：

一：线程状态

（1）新生状态-》创建线程对象然后实现start()方法
（2）就绪状态
（3）运行状态-》cpu调度
（4）阻塞状态
（5）死亡状态

二：停止线程

1.自然终止：线程体正常运行完毕
2.外部干涉：
1）线程类中定义线程体的标识
2）线程体使用该标识
3）提供对外的方法改变该标识
4）外部根据条件调用该方法即可

三：阻塞

1.join:合并线程，Y.join(),则先执行Y对象里面的线程体
2.Thread.yield():暂停线程，当前的方法体
3.Thread.sleep():睡眠,模拟延时，但有可能出现数据异常，资源冲突

四：线程基本信息

 isAlive()：判断线程是否活着，是否未终止
 getPriority()：获取线程的优先级数据，优先级代表的是概率，并非绝对的先后顺序
 setPriority()：设置线程的优先级
 setName()：给线程取名字
 getName()：获取线程名字
 currentThread()：获取当前正在运行的线程对象，也就是取得自己本身

五：线程同步（线程并发）

 synchronized->同步
 (1)同步块:
 synchronized(引用类型 || this || 类.class){}

public void run() {
        synchronized (UseSynchronized.class) {
            while (true) {
                System.out.println(Thread.currentThread().getName() + "获得属性" + a);
            }
        }
    }

 (2)同步方法:
 synchronized 方法名(){}

 public void run() {
        synchronized (test()) {
            while (true) {
                System.out.println(Thread.currentThread().getName() + "获得属性" + a);
            }
        }
    }

(3)同步属性：

synchronized(属性)｛｝

  public void run() {
        synchronized (a) {
            for (int i = 0; i < 20; i++) {
                System.out.println(Thread.currentThread().getName() + "获得属性" + a);
            }
        }
    }

  多个线程访问同一份资源,确保资源安全->线程安全
  线程安全则效率低，反之
 

六：死锁

①、互斥条件：资源不能被共享，只能被同一个进程使用；

②、请求与保持条件：已经得到资源的进程可以申请新的资源；

③、非剥夺条件：已经分配的资源不能从相应的进程中强制剥夺；

④、循环等待条件：系统中若干进程形成环路，该环路中每个进程都在等待相邻进程占用的资源。

过多的同步可能造成死锁-->利用生产者消费者模式解决死锁问题

 七：创建线程的三种方式：

（1）继承Thread类，自动拥有Thread类的所有属性，方法。

//第一种创建线程的方式：继承Thread类
public class CreateThread1 extends Thread {

    @Override
    public void run() {
        try {
            CreateThread1 t1 = new CreateThread1();
            t1.join(1000);
            System.out.println("当前线程状态->" + t1.getState());
            t1.sleep(1000);
            System.out.println("当前线程状态->" + t1.getState());
            for (int i = 0; i < 100; i++) {
                System.out.println("-->通过继承Thread类实现线程的创建");
            }
        } catch (InterruptedException e) {

        }
    }

    @Test
    public void test() {
        //new 出线程对象
        CreateThread1 createThread1 = new CreateThread1();
        //设置线程名称
        createThread1.setName("线程1");
        //获取上下文类加载器
        System.out.println("当前线程的类加载器：" + createThread1.getContextClassLoader());
        //获取当前线程的状态
        System.out.println("当前线程的状态：" + createThread1.getState());
        //判断当前线程是否处于运行，存活状态
        System.out.println("当前线程是否正在运行：" + createThread1.isAlive());
        //获取当前线程的名称
        System.out.println("当前线程的名称：" + createThread1.getName());
    }


    public static void main(String[] args) {
        new CreateThread1().start();
    }
}

（2）实现Runnable接口，通过重写run()方法，需要借助Thread类进行包装然后启动线程。

//通过实现Runnable接口实现线程的创建
public class CreateThread2 implements Runnable {

    public void run() {
        System.out.println("-->通过实现Runnable接口创建线程");
    }

    public static void main(String[] args) {
        new Thread(new CreateThread2()).start();
    }
}

（3）JDK1.5之后出现了Callable接口，通过实现Callable接口，重写call()方法同样具有修改线程执行体内部的作用，同时call()方法还具有抛出异常的作用。

//通过实现jdk1.5之后推出的Callable接口实现线程创建
public class CreateThread3 implements Callable<Object> {

    public Object call() throws Exception {
        System.out.println("-->通过实现Callable接口创建线程");
        return null;
    }

    @Test
    public void testThread() {
        //通过FutureTask类包装实现Callable接口的类启动线程
        FutureTask<Object> task = new FutureTask<Object>(new CreateThread3());
        new Thread(task).start();
    }
}

八.线程池：

//对线程池进行简单了解，简单使用
public class ThreadPool {
    //创建一个可根据需要创建线程的线程池
    private static ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    //创建一个单例的线程池，也就是线程池中仅能够存放一个线程
    private static ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
    //创建一个固定大小的线程池，自定义大小为3
    private static ExecutorService fixedThreadPool=Executors.newFixedThreadPool(3);

    //构造器私有化，外部无法new出对象
    private ThreadPool() {
    }

    public static void main(String[] args) {
        //将一个任务扔到线程池中
       cachedThreadPool.execute(new Runnable() {
           public void run() {
               System.out.println("任务执行中！");
           }
       });

    /*   singleThreadPool.execute(new Runnable() {
           public void run() {
               System.out.println("任务执行中！");
           }
       });*/
       cachedThreadPool.submit(new Runnable() {
           public void run() {
               System.out.println("结果显示！");
           }
       });
       //直接将线程池中所有的任务关闭，不再执行
       cachedThreadPool.shutdown();
    }
}

代码：

1.具体角色：

package com.test;
/*使用Runnable创建线程
 * 1.使用静态代理模式实现启动多线程
 * （1）创建真实角色
 * （2）创建代理角色
*/
public  class Singer implements Runnable {

    @Override
    public void run() {
        System.out.println("歌手线程执行->歌手曹操准备上台唱歌。。");
    }
}

2.代理角色：保持对具体角色的引用

package com.test;

public class Agent implements Runnable{
    Singer singer=new Singer();
    Thread t1=new Thread(singer);
    public Agent(Singer singer) {
        super();
        this.singer = singer;
    }
    private void before() {
        System.out.println("代理员线程执行->代理员已经准备好台前工作，歌手就绪!");
    }
    private void after() {
        System.out.println("代理员线程执行->代理员已经收拾完场地，护送歌手离开!");
    }

    @Override
    public void run() {
        System.out.println("歌手线程未启动:"+t1.isAlive());
        before();
        t1.start();    
        t1.setName("歌手线程");
        System.out.println("当前线程为:"+t1.currentThread());
        System.out.println("当前线程名称:"+t1.getName());
        System.out.println("歌手线程启动:"+t1.isAlive());
        //这里存在多线程运行的延时，即代理员的线程可能运行在歌手的线程前面
        after();
    }
}

3.场景模拟：

package com.test;
/*
 * 场景模拟：实现多线程的启动
 */
public class Client {

    public static void main(String[] args) throws InterruptedException {
        //具体角色
        Singer singer=new Singer();
        //代理角色
        Agent ag=new Agent(singer);
        Thread p2=new Thread(ag);
        //启动线程
        p2.start();
    }
}

效果截图:

 利用生产者消费者模式解决死锁问题:

1.共享资源

package com.deadclock;
//共享资源
public class Movie {
    private String pic;
    //定义一个信号灯，用于标识生产者消费者的处理结果，以及通知顺序
    private boolean flag=true;

    //加入同步锁防止资源分配不当出现死锁
    public  synchronized void play(String pic) {
        
        if(!flag) {//生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //开始生产
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {

            e.printStackTrace();
        }
        //生产完毕
        this.pic=pic;
        //通知消费者
        this.notify();
        this.flag=false;
    }

    public synchronized void watch() {
        if(flag) {//消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //开始消费
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //消费完毕
        System.out.println(pic);
        //通知生产者
        this.notify();
        this.flag=true;
    }

}

2.具体访问共享资源角色：

package com.deadclock;
//使用共享资源的具体角色
public class Player implements Runnable{
    
    private Movie m;
    
    //构造器，传入movie对象
    public Player(Movie m) {
        super();
        this.m=m;
    }
    
    @Override
    public void run() {
        
        for(int i=0;i<=10;i++) {
            if(i%2==1) {
                m.play("奇数"+i);
            }
            else 
                m.play("偶数"+i);
        }
    }
}

package com.deadclock;
//使用共享资源的具体角色
public class Watcher implements Runnable{

    private Movie m;
    
    //构造器，传入movie对象
    public Watcher(Movie m) {
        super();
        this.m=m;
    }
    
    @Override
    public void run() {
        for(int i=0;i<=10;i++) {
            m.watch();
        }
    }
}

3.场景模拟

package com.deadclock;

public class Client {

    public static void main(String[] args) {
        //共享资源初始化
        Movie m=new Movie();
        //具体使用资源对象
        Player p=new Player(m);
        Watcher w=new Watcher(m);
        //创建线程
        Thread t1=new Thread(p);
        Thread t2=new Thread(w);
        //开启线程
        t1.start();
        t2.start();
    }

}

效果截图：

面向对象编程:

场景模拟，使用多线程描述代驾员帮忙代驾的场景
  1.首先司机到达代驾员处
  2.正式会面
  3.然后开始任务交接
  4.结束

1.具体的驾驶员角色

package com.oob;
//具体角色->驾驶者
public class Driver implements Runnable{
    //驾驶员的名字和车
    private String dName;
    private String car;
    
    public String getdName() {
        return dName;
    }
    public void setdName(String dName) {
        this.dName = dName;
    }
    public String getCar() {
        return car;
    }
    public void setCar(String car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "驾驶者线程-->>驾驶者"+dName+"已将"+car+"开往代驾员所在位置！";
    }
    //构造方法
    public Driver(String dName, String car) {
        super();
        this.dName = dName;
        this.car = car;
    }
    public Driver() {

    }
    @Override
    public void run() {
        Driver d=new Driver("小王","奔驰");
        System.out.println(d.toString());
    }
}

2.代理角色

package com.oob;
//代理角色，代驾
public class DriverProxy implements Runnable{
    //代驾员的名字，代驾起点，终点
    private String pName;
    private String start;
    private String last;
    
    public String getpName() {
        return pName;
    }

    public void setpName(String pName) {
        this.pName = pName;
    }

    public String getStart() {
        return start;
    }

    public void setStart(String start) {
        this.start = start;
    }

    public String getLast() {
        return last;
    }

    public void setLast(String last) {
        this.last = last;
    }

    public DriverProxy(String pName, String start, String last) {
        super();
        this.pName = pName;
        this.start = start;
        this.last = last;
    }

    public DriverProxy() {
        super();
    }
    
    @Override
    public String toString() {
        return "代驾员线程-->>代驾员"+pName+"正开着客户的车从"+start+"出发前往"+last+"!";
    }

    @Override
    public void run() {
        Driver d=new Driver("小王","奔驰");
        DriverProxy p=new DriverProxy("小张","锦绣花园","万达广场");
        System.out.println("代驾员线程-->>代驾员"+p.getpName()+"与客户"+d.getdName()+"成功会面！");
        System.out.println(p.toString());
        System.out.println("代驾员线程-->>代驾员"+p.getpName()+"与客户"+d.getdName()+"分开,并将"+d.getCar()+"归还!");
        
    }

}

3.场景模拟

package com.oob;
/*场景模拟，使用多线程描述代驾员帮忙代驾的场景
  1.首先司机到达代驾员处
  2.正式会面
  3.然后开始任务交接
  4.结束
*/
public class Client {

    public static void main(String[] args) {
        //具体角色
        Driver d=new Driver();
        Thread t1=new Thread(d);
        t1.start();
        //代理者角色
        DriverProxy p=new DriverProxy();
        Thread t2=new Thread(p);
        //启动线程    -->由此可以看出当线程启动后具体角色以及代理者角色均被初始化导致数据为空
        t2.start();
    }
}

效果截图：

ps:文章仅作学习了解，如有不对之处欢迎大佬指正。