• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

多线程与并发

java 来源:凯旋的皇阿玛 6次浏览

文章目录

1、什么是进程

程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念,而进程是程序在处理机上的一次执行过程,是个动态的概念。

进程是一个具有一定独立功能的程序,一个实体,每一个进程都有自己的地址空间。

2、进程的状态

进程执行的间断性决定了进程可能具有多种状态,事实上,运行中的进程具有以下三种状态:

  • 就绪状态
  • 运行状态
  • 阻塞状态

3、线程

线程实际上是在进程的基础上进一步划分,一个进程启动后。里面的若干程序又可以划分若干个线程。

线程:是进程的一个执行路径,共享一个内存空间,线程之间可以自由切换,并发执行,一个进程最少有一个线程

并行:两个任务同时运行(多个CPU)

并发:就是将任务轮流执行,由于CPU时间片运行时间较短,就会感觉两个任务在同时执行。

4、线程的基本使用

  • 一种是继承Thread类
class MyThread extends Thread{
    public void run{
        //逻辑处理
    }
}
MyThread mt = new MyThread();
mt.start()
  • 另外一种是实现Runnable接口(推荐使用)
class MyRunnable implements Runnable{
    public void run(){
        //逻辑处理
    }
}
MyRunnable mr = new MyRunnable();
Thread t = new Thread(mr);
t.start();

5、线程休眠

pulic static void sleep(long mills)

在当前线程的执行中,暂停指定的毫秒数,释放CPU的时间片

6、守护线程与yield

public final void setDaemon(boolean on)
将此线程标记为daemon线程或用户线程,当运行的唯一线程都是守护进程线程时,Java虚拟机将退出
参数为true时,线程为守护线程

public static void yield()
暂停当前正在执行的线程对象,并执行其他线程

void setPriority(int newPriority) 
更改线程优先级
static int MAX_PRIORITY 最大优先级,抢到CPU时间片的概率大
static int MIN_PRIORITY 最小优先级
static int NORM_PRIORITY 默认优先级
package per.learn.multhread;


public class ThreadDemo2 {
    public static void main(String[] args) {
        MyRunnable2 mr = new MyRunnable2();
        Thread tr  = new Thread(mr);
        tr.setDaemon(true);//设置为守护线程
        tr.start();
        for(int i =0;i<10;i++){
            System.out.println("main--"+i);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class MyRunnable2 implements Runnable{
    private long millis;

    @Override
    public void run() {
        for(int i =0;i<10;i++){
            System.out.println("--"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


OUT:
main--0
--0
main--1
main--2
--1
main--3
main--4
--2
main--5
main--6
main--7
--3
main--8
main--9
--4

main运行完,线程tr并未执行完。

7、join和中断线程

public final void join() throws InterruptedException
等待这个线程死亡
调用此方法的行为方式与调用相同
join(0)

public void interrupt()
中断这个线程
除非当前线程中断自身,这是允许的
public static boolean interrupted()
测试当前线程是否中断,该方法会清除中断状态

join方法:
加入线程,将调用的线程执行指定时间或执行完毕,再执行其他

package per.learn.multhread;

public class ThreadDemo3 {
    public static void main(String[] args) {
        MyRunnable3 mr3 = new MyRunnable3();
        Thread t = new Thread(mr3);
        t.start();
        for(int i =0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(i==5){
                try{
                    t.join();//让线程t执行完毕
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //t.interrupt();//中断线程,只是做了中断标记,抛出异常,线程仍然会执行
            }
        }
    }
}
class MyRunnable3 implements Runnable{
    @Override
    public void run() {
        for(int i =0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Out:
main--0
Thread-0--0
main--1
main--2
Thread-0--1
main--3
main--4
Thread-0--2
main--5
Thread-0--3
Thread-0--4
Thread-0--5
Thread-0--6
Thread-0--7
Thread-0--8
Thread-0--9
main--6
main--7
main--8
main--9

package per.learn.multhread;

public class ThreadDemo3 {
    public static void main(String[] args) {
        MyRunnable3 mr3 = new MyRunnable3();
        Thread t = new Thread(mr3);
        t.start();
        for(int i =0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(i==5){
//                try{
//                    t.join();//让线程t执行完毕
//                }catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                t.interrupt();//中断线程,只是做了中断标记,抛出异常,线程仍然会执行
            }
        }
    }
}
class MyRunnable3 implements Runnable{
    @Override
    public void run() {
        for(int i =0;i<10;i++){
            if(Thread.interrupted()){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace(); //会将中断状态清除
                Thread.currentThread().interrupt();//将中断状态重新标记
            }
        }
    }
}


main--0
Thread-0--0
main--1
main--2
Thread-0--1
main--3
main--4
main--5
Thread-0--2
main--6
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at per.learn.multhread.MyRunnable3.run(ThreadDemo3.java:35)
	at java.lang.Thread.run(Thread.java:748)
main--7
main--8
main--9

8、线程同步

  • 多线程共享数据
    在多线程的操作中,多个线程可能同时处理同一个资源,这就是多线程中的共享数据,会发生不安全的情况。
  • 线程同步

同步代码块:

同步是一种高开销的操作,因此应该尽量减少同步的内容。
通常没有必要同步整个方法,使用synchronized代码块同步关键代码即可。

synchronized(object){ 
    要同步的操作
}

例:

package per.learn.multhread;

import sun.awt.windows.ThemeReader;

public class ThreadDemo4 {
    public static void main(String[] args) {
        MyRunnable5 mr5 = new MyRunnable5();
        Thread t1 = new Thread(mr5);
        Thread t2 = new Thread(mr5);
        //模拟两个窗口
        t1.start();
        t2.start();
    }
}
class MyRunnable5 implements Runnable{
    private int ticket=10;//车票
    private Object obj =  new Object();
    @Override
    public void run() {
        for(int i=0;i<300;i++){
            synchronized (obj){
                if(ticket > 0){
                    ticket--;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("您购买的车票已剩余"+ticket+"张");
                }
            }
        }
    }
}

同步方法

public synchronized void method(){
要同步的操作
}

同步的方法是当前对象(this)

注: synchronized关键字也可以修饰静态方法,此时如果调用该静态方法,将会锁住整个类

package per.learn.multhread;

import sun.awt.windows.ThemeReader;

public class ThreadDemo4 {
    public static void main(String[] args) {
        MyRunnable5 mr5 = new MyRunnable5();
        Thread t1 = new Thread(mr5);
        Thread t2 = new Thread(mr5);
        //模拟两个窗口
        t1.start();
        t2.start();
    }
}
class MyRunnable5 implements Runnable{
    private int ticket=10;//车票
    private Object obj =  new Object();
    private synchronized void method(){
        if(ticket > 0){
            ticket--;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("您购买的车票已剩余"+ticket+"张");
        }
    }
    @Override
    public void run() {
        for(int i=0;i<300;i++){
            method();
                }
            }
}

Lock

结构化更加方便,以上两种只能等同步方法或同步代码块执行完毕后才能释放锁。
ReentrantLock类是可重入、互斥、实现了Lock接口的锁,
它与使用synchronized方法和快具有相同的基本行为和语义,并且扩展了其能力

ReenreantLock类的常用方法有:

    ReentrantLock() : 创建一个ReentrantLock实例 
    lock() : 获得锁 
    unlock() : 释放锁 
注:ReentrantLock()还有一个可以创建公平锁的构造方法,但由于能大幅度降低程序运行效率,不推荐使用 
package per.learn.multhread;

import sun.awt.windows.ThemeReader;

import java.util.concurrent.locks.ReentrantLock;

public class ThreadDemo4 {
    public static void main(String[] args) {
        MyRunnable5 mr5 = new MyRunnable5();
        Thread t1 = new Thread(mr5);
        Thread t2 = new Thread(mr5);
        //模拟两个窗口
        t1.start();
        t2.start();
    }
}
class MyRunnable5 implements Runnable{
    private int ticket=10;//车票
    private Object obj =  new Object();
    ReentrantLock lock = new ReentrantLock();
    private void method2(){
        lock.lock();//锁
        try{
            if(ticket > 0){
                ticket--;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("您购买的车票已剩余"+ticket+"张");
            }
        }finally {
            lock.unlock();//释放锁
        }
    }
    @Override
    public void run() {
        for(int i=0;i<300;i++){
            method2();
                }
            }
}

注意:

  • 如果synchronized关键字能满足用户的需求,就用synchronized,因为它能简化代码
  • 如果需要更高级的功能,就用ReentrantLock类,此时要注意及时释放锁,否则会出现死锁,通常在finally代码释放锁

volatile

  • volatile关键字为域变量的访问提供了一种免锁机制,
  • 使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新,
  • 因此每次使用该域就要重新计算,而不是使用寄存器中的值
  • volatile不会提供任何原子操作,它也不能用来修饰final类型的变量

阻塞队列

LinkedBlockingQueue 类常用方法

  • LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue
  • put(E e) : 在队尾添加一个元素,如果队列满则阻塞
  • size() : 返回队列中的元素个数
  • take() : 移除并返回队头元素,如果队列空则阻塞

当队列满时:
add()方法会抛出异常
offer()方法返回false
put()方法会阻塞

使用原子变量实现线程同步

需要使用线程同步的根本原因在于对普通变量的操作不是原子的。

那么什么是原子操作呢?
原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作
即-这几种行为要么同时完成,要么都不完成。

在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类,
使用该类可以简化线程同步。

其中AtomicInteger 表可以用原子方式更新int的值,可用在应用程序中(如以原子方式增加的计数器),
但不能用于替换Integer;可扩展Number,允许那些处理机遇数字类的工具和实用工具进行统一访问。

AtomicInteger类常用方法:
AtomicInteger(int initialValue) : 创建具有给定初始值的新的AtomicInteger
addAddGet(int dalta) : 以原子方式将给定值与当前值相加
get() : 获取当前值

9、死锁

过多的同步有可能出现死锁。

经典案例

如:服务员需要等待厨师准备好食物,然后通知服务员上菜,然后回去继续等待,厨师代表生产者,服务员代表消费者。

package per.learn.multhread;

/**
 * 两个线程协同工作,先生产,再消费
 */
public class ProducterCustomerDemo {
    public static void main(String[] args) {
        Food food = new Food();//共享food对象
        Producter p = new Producter(food);
        Customer c = new Customer(food);
        //先生产,再消费
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();
    }
}
/**
 * 消费者
 */
class Customer implements Runnable{
    private Food food;
    public Customer(Food food){
        this.food =food;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            food.get();
        }
    }
}

/**
 * 生产者
 */
class Producter implements Runnable{
    private Food food;
    public Producter(Food food){
        this.food=food;
    }

    @Override
    public void run() {
        //模拟生产20份
        for (int i = 0; i <20 ; i++) {
            if(i%3==0){
                food.set("锅包肉","酸甜口味");
            }
            else if(i%3==1){
                food.set("佛跳墙","多辣");
            }else{
                food.set("小炒肉","多肉");
            }
        }
    }
}
/*
共享
 */
class Food{
    private String name;
    private String describe;
    private boolean flag = true;//true 表示生产,false表示消费
    /**
     * 生产产品
     */
    public synchronized void set(String name,String describe){
        if(!flag){
            //表示不能生产,要释放cpu和锁
            try {
                this.wait();//线程进入等待状态,释放监视器所有权(对象锁)
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.setName(name);
        try {
            Thread.sleep(1000);  //模拟生产过程 产生时间差
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setDescribe(describe);
        flag = false;
        this.notify();//唤醒等待的线程(随机的其中一个)
    }

    /**
     * 消费
     */
    public synchronized  void get(){
        if(flag){
            //表示不能消费
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.getName()+"->"+this.getDescribe());
        flag = true;
        this.notify();
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescribe() {
        return describe;
    }

    public void setDescribe(String describe) {
        this.describe = describe;
    }

    @Override
    public String toString() {
        return "Food{" +
                "name='" + name + '\'' +
                ", describe='" + describe + '\'' +
                '}';
    }

    public Food(String name, String describe) {
        this.name = name;
        this.describe = describe;
    }

    public Food() {
    }
}

线程生命周期和线程池


线程池是预先创建线程的一种技术。线程池在还没有任务来之前,创建一定数量的线程,放入空闲队列中,然后对这些资源进行复用。减少频繁的创建和销毁对象。线程池接口是ExecutorService。

Executor接口:
执行已提交的Runnable任务对象

ExecutorService:
Executor提供了管理终止方法,以及可为追踪一个或多个异步任务执行状况而生成Future的方法。

Executors类:
此包中所定义的Executor、ExecutorService等的工厂和实用方法。

newSingleThreadExecutor:
创建单线程线程池。相当于单线程串行执行所有任务,如果这个唯一线程因为异常结束,那么会有一个新的线程替代它,此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

newFixedThreadPool:创建固定大小的线程池,每次提交一个任务就创建一个线程,直到达到线程池最大大小。
如果某个线程因为异常结束,就会补充一个新线程

newCachedThredPool: 创建一个可缓存的线程池,如果线程池的大小超过了处理任务所需要的线程,那么就会收回部分空闲(60s不执行任务)的线程,线程池不会对线程池大小做限制,依赖操作系统(或者说JVM)能创建的最大线程池大小。

newSchedeledThreadPool:创建一个大小无限的线程池,支持定时及周期性执行任务的需求。(需要指定初始大小)

package per.learn.multhread;
import java.util.concurrent.*;

public class ThreadDemo5 {
    public static void main(String[] args) {
        //创建线程池(4种)
        //ExecutorService es = Executors.newSingleThreadExecutor();
        //ExecutorService es = Executors.newFixedThreadPool(2);
        ScheduledExecutorService es = Executors.newScheduledThreadPool(2);
        //es.execute(new MyRunnable6());
        //es.execute(new MyRunnable6());
        es.schedule(new MyRunnable6(),3000, TimeUnit.MILLISECONDS);

        es.shutdown();//结束
    }
}
class MyRunnable6 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

面试题

sleep() wait de 区别:
sleep:让线程进入休眠状态,让出CPU时间时间片,不释放对象锁

wait:让线程进入等待状态,让出CPU时间片,释放对象锁,等待其他线程通过notify()方法来唤醒,也可以设置等待时间,该线程再次竞争资源


版权声明:本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。
喜欢 (0)