多线程

多线程

一、进程与线程

进程

进程就是程序的一次执行过程,它是一个动态的概念,是系统资源分配的单位。比如：火车。 通常再一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义,线程是CPU调度和执行的单位。比如：火车厢 。

线程

线程就是独立的执行路径 在程序运行时,即使没有自己创建线程,后台也会有多个线程,比如主线程,GC线程 main()称之为主线程,为系统的入口,用于执行整个程序 priority = 5； 在一个进程中,如果开辟了多个线程,线程的运行是由调度器安排调度的,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的 对同一份资源操作时mm会存在资源抢夺的问题,需要加入并发控制 线程会带来额外的开销,如CPU调度时间,并发控制开销 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致

线程创建（重点）

三种创建方式

一、继承自Thread类,重写run方法,创建实例调用start方法

public class ThreadTest extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程方法被调用了");
    }
    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
    }
}

二、实现Runnable接口,实现run方法,创建Thread时作为参数传入,调用start方法

 

public class TestRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("实现了run方法");
    }
    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();    
        Thread thread = new Thread(new TestRunnable());
        thread.start();
      }
}

三、实现Callable接口,重写call方法,

可以定义返回值

可以抛出异常

public class TestCallable implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        System.out.println("创建成功");
        return true;
    }
    public static void main(String[] args) {
        TestCallable callable = new TestCallable();
​
        //创建执行服务
        ExecutorService service = Executors.newFixedThreadPool(1);
        //提交执行
        Future<Boolean> result = service.submit(callable);
        //获取返回值
        boolean isTrue = result.get();
        service.shutdownNow();
     }
}

线程状态

创建状态：new 就绪状态：start 阻塞状态：sleep，wait 运行状态：run（获取cpu片段） 死亡状态：dead（一个线程只能start一次）

线程方法

一、停止线程

1. 线程休眠 sleep() sleep(毫秒数)指定当前线程停止的实践，阻塞 sleep()存在异常InteruptedException sleep()时间到达后线程进入就绪状态 sleep()可以模拟网络延时,倒计时等 每一个对象都有一个锁,sleep不会释放锁

2. 线程礼让 yield() 礼让线程,让当前正在执行的线程暂停,但不阻塞 将线程从运行状态转为就绪状态 让CPU重新调度,礼让不一定成功,看CPU心情

3. 线程强制执行 join() Join合并线程,待此线程执行完成后,在执行其他线程,其他线程阻塞 可以想象成插队

4. 线程优先级 java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程;线程调度器按照优先级决定该调度哪个线程来执行 线程的优先级用数字来表示,范围从1~10 Thread.MIN_PRIORITY = 1 Thread.MAX_PRIORITY= 10 Thread.NORM_PRIORITY = 5 使用getPriority()和setPriority()来获取或改变优先级

5. 守护线程setDeamon() 线程分为用户线程和守护线程 虚拟机必须确保用户线程执行完毕 虚拟机不用等待守护线程执行完毕 如后台记录操作日志,监控内存,垃圾回收

线程同步（重点）

背景（问题）

票的剩余数会为负数，银行账户会为负数，list的长度会少?

处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候我们就需要线程同步,线程同步其实是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面的线程使用完毕,下一个线程在使用 ​ 由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问的冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制syncronized,当一个线程获得对象的排他锁,独占资源,其他线程必须等待,使用后释放锁即可,存在一下问题

• 一个线程持有锁会导致其他所有需要此锁的进程挂起

• 在多线程竞争的情况下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题

• 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置,引起性能问题

死锁 多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源释放才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形,某一个同步块同时拥有"两个以上的对象锁"时,就可能发生死锁现象 死锁产生的条件 互斥条件: 一个资源每次只能被一个进程使用 请求保持条件: 一个进程因请求资源而阻塞时.对以获得的资源保持不放 不剥夺条件: 进程已获得的资源,在未使用完之前,不能强行剥夺 循环等待条件: 若干进程之间形成一种头尾相接的循环等待资源关系

三种解决方法：

一、同步方法

同步方法中无需指定同步监视器,因为同步方法中的同步监视器就是this,就是这个对象本身,或者是class

同步方法在方法上添加synchronized关键子,锁的是对象本身

//不安全的买票
public class UnsafeButTicket {
    public static void main(String[] args) {
        BuyTicket bt=new BuyTicket();
        new Thread(bt,"我").start();
        new Thread(bt,"你").start();
        new Thread(bt,"黄牛党").start();
    }
}
​
class BuyTicket implements Runnable{
    //票
    private int ticketNums=10;
     boolean flag=true;//外部停止方式
    @Override
    public void run() {
        //买票
        while (flag){
            buy();
        }
    }
​
​
    public synchronized void buy(){//锁了方法，相当于this 把类给锁住
​
        //判断是否有票
        if(ticketNums<=0){
            System.out.println("票没了");
            flag=false;
            return ;
        }
        //模拟延时
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+ticketNums--);
    }
}
​

二、同步块: synchronized(obj){}

obj称之为同步监视器 obj可以是任何对象,但是推荐使用共享资源作为同步监视器

同步监视器的执行过程

第一个线程访问,锁定同步监视器,执行其中的代码 第二个线程访问,发现同步监视器被锁定,无法访问 第一个线程访问完毕,解锁同步监视器 第二个线程访问,发现同步监视器没有锁,然后锁定并访问

​
//不安全取钱
    //两个人去银行取钱，账户
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account=new Account(100,"结婚基金");
        Drawing you=new Drawing(account,50,"你");
        Drawing girlFriend=new Drawing(account,100,"女朋友");
        you.start();
        girlFriend.start();
    }
}
//账户
class Account{
    int money;//余额
    String name;//卡名
​
    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//银行：模拟取款
class Drawing extends Thread{
    Account account;//账户
    //取了多少钱；
    int drawingMoney;
    //现在手里又多少钱
    int nowMoney;
    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account=account;
        this.drawingMoney=drawingMoney;
​
    }
    //取钱
​
    @Override
    public void run() {
        synchronized (account) {//锁的对象是变化的量，锁需要增删改的对象
            //判断有没有钱
            if (account.money - drawingMoney <= 0) {
                System.out.println(Thread.currentThread().getName() + "钱不够");
                return;
            }
            //卡内余额
            account.money -= drawingMoney;
            //手里的钱
            nowMoney += drawingMoney;
            System.out.println(account.name + "余额为:" + account.money);
            System.out.println(this.getName() + "手里的钱:" + nowMoney);
        }
    }
}
​
//List不是线程安全的
public class UnsafeList {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        for (int i = 0; i <1000 ; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(list.size());
    }
}

 

三、Lock锁

从JDK1.5开始,java提供了更为强大的线程同步机制——通过显示定义同步锁对象来实现同步,同步锁使用lock对象来充当

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象

ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中.比较常用的是ReentrantLock,可以显示加锁,释放锁

实战

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
    class TestLock2 implements Runnable {
​
        int ticketNums = 10;
        //定义Lock锁
        private ReentrantLock reentrantLock = new ReentrantLock();
        @Override
        public void run() {
            while (true) {
                try {
                    reentrantLock.lock(); //加锁
                    if(ticketNums > 0 ){
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "购买了第" + ticketNums-- + "张票");
​
                    } else {
                        break;
                    }
                } finally {
                    //解锁
                    reentrantLock.unlock();
                }
        }
    }
}

和synchronized对比 Lock是显示锁(手动开启和关闭,别忘记关闭锁) synchronized是隐式锁,出了作用域自动释放 Lock只有代码块锁,synchronized有代码块锁和方法锁 使用lock锁,JVM将花费较少的时间来调度线程,性能更好,并且具有更好的扩展性(提供更多的子类) 优先使用顺序 Lock > 同步代码块 > 同步方法

线程协作

生产者和消费者问题

假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库产品取走消费 如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止 如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止 这是一个线程同步问题,生产者和消费者共享一个资源,并且生产者和消费者之间相互依赖,互为条件

对于生产者,没有生产产品之前,要通知消费者等待,而生产了产品之后,又要马上通知消费者消费 对于消费者,在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费 在生产者消费者问题上,仅有synchronized是不够的 synchronized可阻止并发更新同一个共享资源,实现了同步 synchronized不能用来实现不同线程之间消息传递(通信)

解决方式 并发协作模式"生产者/消费者模式" ===>管程法

生产者: 负责生产数据的模块(可能是方法,对象,线程,数组) 消费者: 负责处理数据的模块(可能是方法,对象,线程,数组) 缓冲区: 消费者不能直接使用生产者的数据,他们之间有个缓冲区 生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

一、测试生产者消费者模型 --->管程法

//产品
public class Product {
    private int id;
    public Product(int id) {
        this.id = id;
    }
​
    public int getId() {
        return id;
    }
​
    public void setId(int id) {
        this.id = id;
    }
}
//消费者
public class ConsumerThread extends Thread {
    private SyncContainer syncContainer;
​
    public ConsumerThread(SyncContainer syncContainer) {
        this.syncContainer = syncContainer;
    }
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            Product pop = syncContainer.pop();
            System.out.println("消费了第"+ pop.getId() + "号产品");
        }
    }
}
//生产者
public class ProviderThread extends Thread {
    //创建好的缓冲区
    private SyncContainer syncContainer;
​
    public ProviderThread(SyncContainer syncContainer) {
        this.syncContainer = syncContainer;
    }
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了" + i + "只鸡!");
            syncContainer.push(new Product(i));
        }
    }
}

 

//容器
public class SyncContainer {
    //容器大小
    Product[] products = new Product[10];
    //容器计数器
    int count = 0;
​
    //生产者放入产品
    public synchronized void push(Product product){
        //如果容器满了,就要等待消费者
        //通知消费者消费,生产者等待
        if(count == products.length) {
            try {
                this.wait();
            } catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        //如果容器没有满,就要生产产品
        products[count] = product;
        count++;
        //可以通知消费者消费
        this.notifyAll();
    }
    //消费者消费产品
    public synchronized Product pop(){
        //判断容器是否为空
        if(count == 0){
            //通知生产者生产.消费者等待
            try {
                this.wait();
            } catch (InterruptedException e){
                e.printStackTrace();
            }
        }
​
        //如果可以消费
        count--;
        Product product =  products[count];
​
        //通知生产者生产
        this.notifyAll();
        return product;
    }
}

 

public class Main {
    public static void main(String[] args) {
        SyncContainer container = new SyncContainer();
        new ProviderThread(container).start();
        new ConsumerThread(container).start();
    }
}

二、并发协作模式"生产者/消费者模式" ===>信号灯法

应用场景：生产者和消费者问题

//产品-->节目
public class TV {
​
   //演员表演,观众等待
   //观众观看,演员等待
   String voice;   //表演的节目
   boolean flag = true;
​
   //表演
   public synchronized void play(String voice) {
       if(!flag){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
​
       System.out.println("演员表演了" + voice);
       //通知观众观看
       this.voice = voice;
       this.notifyAll();
       this.flag = !flag;
   }
   
   //观看
   public synchronized void watch(){
       if(flag){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       System.out.println("观众观看了" + voice);
       //通知演员表演
       this.notifyAll();
       this.flag = !flag;
   }
}
​
public class Player extends Thread {
   private TV tv = null;
​
   public Player(TV tv) {
       this.tv = tv;
   }
​
   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           tv.play("表演了" + i + "号节目");
       }
   }
}
​
public class Watcher extends Thread {
​
   private TV tv = null;
​
   public Watcher(TV tv) {
       this.tv = tv;
   }
​
   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           tv.watch();
       }
   }
}
​
//测试生产者消费者问题:信号灯法,标志位解决
public class Main {
​
   public static void main(String[] args) {
       TV tv = new TV();
       new Watcher(tv).start();
       new Player(tv).start();
​
   }
}

使用线程池

使用线程池 背景: 经常创建和销毁,使用量特别大的资源,比如并发情况下的线程,对性能影响很大 思路: 提前创建好多个线程,放入线程池中,使用时直接获取,使用完毕放回池中,可以避免频繁的创建销毁,实现重复利用,类似生活中的工共交通工具 好处 提高了响应速度(减少了创建新线程的时间) 降低资源消耗(重复利用线程池中线程,不需要每次都创建) 便于线程管理(…) corePoolSize: 核心池的大小 maximumPoolSize: 最大线程数 keepAliveTime: 线程没有任务时最多保持多长时间后会终止

public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        ExecutorService service= Executors.newFixedThreadPool(10);
        //newFixedThreadPool 参数为：线程池大小
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //2.关闭连接
        service.shutdown();
    }
}
class MyThread implements Runnable{
​
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}