Java基础03

Java多线程

进程与线程

一个进程可以有多个线程
说起进程，就不得不说下程序。程序是指令和数据的有序集合,其本身没有任何运
行的含义，是一个静态的概念。
而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单
位
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没
有存在的意义。线程是CPU调度和执行的的单位。

程序-->进程-->线程

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

线程不一定立即执行，由CPU安排调度

创建线程的方法一

//创建线程的方法  1 继承thread类  重写run方法
public class TestThead extends Thread {
    @Override
    public void run() {

        for (int i = 0; i < 200; i++) {
            System.out.println("我是创建的线程--->"+i);
        }
    }



    public static void main(String[] args) {
        TestThead threadtest1 = new TestThead();
        threadtest1.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("我是主线程---->"+i);
        }

    }
}

创建线程的方法二

public class TestThread3 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("我是创建的线程--->"+i);
        }
    }
    public static void main(String[] args) {
        TestThread3 threadtest3 = new TestThread3();  //创建一个实现runnable接口的实现类对象，将此对象放入Thread对象中
        new Thread(threadtest3).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("我是主线程---->"+i);
        }

    }
}

实现runnable接口的好处:

实现接口Runnable具有多线程能力
启动线程:传入目标对象+ Thread对象.start()
推荐使用:避免单继承局限性，灵活方便, 方便同一个对象被多个线程使用

创建线程的三种方式：1.继承Thread类 2.实现runnable接口 3. 实现callable接口

Lamda表达式

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

public class TestLamda {

    //2.创建静态内部类
    static class Like2 implements Ilike{
        @Override
        public void lamda() {
            System.out.println("我喜欢lamDa2.0");
        }
    }

    public static void main(String[] args) {
        Ilike l = new Like();
        l.lamda();
        l = new Like2();
        l.lamda();

        //3.创建局部内部类
        class Like3 implements Ilike{

            @Override
            public void lamda() {
                System.out.println("我喜欢lamDa3.0");
            }
        }
        l = new Like3();
        l.lamda();

        //4.匿名内部类

        l = new Ilike(){

            @Override
            public void lamda() {
                System.out.println("我喜欢lamDa4.0");
            }
        };
        l.lamda();
        //5.用lamda简化
        l =()-> {
            System.out.println("我喜欢lamDa5.0");
        };
        l.lamda();

    }
}


//1. 函数式接口
interface Ilike{
    void lamda();
}

class Like implements Ilike{

    @Override
    public void lamda() {
        System.out.println("我喜欢lamDa1.0");
    }
}

总结:
lambda表达式只能有一行代码的情况下才能简化成为-一行，如果有多行，那么就用代码块包裹。
前提是接口为函数式接口
多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号.

public class TestLamda2 {
    public static void main(String[] args) {
         Ilove love = (a)->{ //可以省略int  一个参数的时候可以省略括号
             System.out.println("I love "+a);
        };

         love.love(520);
    }
}

interface Ilove{
    void love(int a);
}

静态代理

静态代理模式总结: .
- 真实对象利代理对象都要实现同一个接口
- 代理对象要代理真实角色
  
  好处:
  1. 代理对象可以做很多真实对象做不J的事情
  2. 真实对象专注做自己的事情

线程休眠

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

线程礼让

public class TestYield  {

    public static void main(String[] args) {
        MyYield t = new MyYield();

        new Thread(t,"a").start();
        new Thread(t,"b").start();

    }

}
//线程的礼让不一定成功，看CPU调度
class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行！");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束执行！");
    }
}

线程的join操作

这个可以理解成插队，不太重要

线程状态

1631186333403

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度
器按照优先级决定应该调度哪个线程来执行。
优先级低只是意味着获得调度的概率低.并不是优先级低就不会被调用了.这都是看CPU的调度
使用以下方式改变或获取优先级getPriority() . setPriority(int xXX)
优先级的设定建议在start(调度前）

守护线程

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

线程同步

由于同一个进程的多个线程共享同一块存储空间,在带来方便的同时，也带来了访问
冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制
synchronized ,当-个线程获得对象的排它锁,独占资源,其他线程必须等待,
使用后释放锁即可.存在以下问题:

一个线程持有锁会导致其他所有需要此锁的线程挂起;
在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时，引
起性能问题;
如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒
置,引起性能问题.

public class TestThread5 {
    public static void main(String[] args) {
        buyTicket buy = new buyTicket();
        new Thread(buy,"高帅").start();
        new Thread(buy,"田永平").start();
        new Thread(buy,"蔡鹏瑞").start();
    }
}

class buyTicket implements Runnable{
    private int ticketNum = 10;
    boolean flag = true; //外部停止方法

    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void buy() throws InterruptedException {

        if(ticketNum<=0){
            flag = false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"买了第"+ticketNum--+"张票");
    }
}

运行结果:
蔡鹏瑞买了第10张票
田永平买了第9张票
高帅买了第10张票
高帅买了第8张票
蔡鹏瑞买了第8张票
田永平买了第7张票
高帅买了第4张票
田永平买了第5张票
蔡鹏瑞买了第6张票
田永平买了第3张票
高帅买了第2张票
蔡鹏瑞买了第3张票
蔡鹏瑞买了第-1张票
田永平买了第1张票
高帅买了第0张票

进程已结束，退出代码 0
    
    public synchronized void buy() throws InterruptedException {

        if(ticketNum<=0){
            flag = false;
            return;
        }
        Thread.sleep(500);
        System.out.println(Thread.currentThread().getName()+"买了第"+ticketNum--+"张票");
    }
给buy方法上锁。

解决线程不安全的方法

同步块: synchronized (Obj)
- Obj称之为同步监视器
- Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this ,就是
  这个对象本身,或者是class [反射中讲解]

同步监视器的执行过程

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

死锁

产生死锁的四个必要条件:

互斥条件:一个资源每次只能被一个进程使用。
请求与保持条件:一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件 :进程已获得的资源，在末使用完之前，不能强行剥夺。
循环等待条件 :若干进程之间形成- -种头尾相接的循环等待资源关系。

Lock锁与synchronized

class buyTicket implements Runnable {
    private int ticketNum = 10;
    boolean flag = true; //外部停止方法

    private final ReentrantLock lock = new ReentrantLock(); //定义lock锁

    @Override
    public void run() {
        while (flag) {
            try {
                lock.lock();
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }

    public  void buy() throws InterruptedException {

        if (ticketNum <= 0) {
            flag = false;
            return;
        }
        Thread.sleep(500);
        System.out.println(Thread.currentThread().getName() + "买了第" + ticketNum-- + "张票");
    }
 }

lock与synchronized区别

Lock是显式锁(手动开启和关闭锁，别忘记关闭锁 synchronized是隐式锁，出了
作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用L ock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展
性(提供更多的子类)
优先使用顺序:
Lock >同步代码块(已经进入了方法体，分配了相应资源) >同步方法(在方
法体之外)

生产者消费者模式

管程法

public class TestPC {

    public static void main(String[] args) {
        Buffer buffer = new Buffer();
        new Productor(buffer).start();
        new Consumer(buffer).start();
    }
}

//生产者
class Productor extends Thread{
    Buffer buffer = new Buffer();

    public Productor(Buffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了第"+i+1+"只鸡");
            buffer.push(new Chicken(i));
        }
    }
}

class Consumer extends Thread{
    Buffer buffer = new Buffer();

    public Consumer(Buffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了第"+buffer.pop().id+"只鸡");
        }
    }
}

class Chicken{
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}

class Buffer{
    Chicken[] chickens = new Chicken[10];
    int count = 0; //计数器

    public synchronized void push(Chicken chicken){
        if(count == chickens.length){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            chickens[count] = chicken;
            count++;

            //通知消费者消费
        this.notifyAll();
    }

    public synchronized Chicken pop(){
        if(count==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        count--;  //个数  不是下标  所以得先减去1
        Chicken chicken = chickens[count];


        //通知生产者生产
        this.notifyAll();
        return chicken;
    }

}

线程池

JDK 5.0起提供了线程池相关API: ExecutorService和Executors
ExecutorService:真正的线程池接口。
常见子类ThreadPoolExecutor
void execute(Runnable command) :执行任务/命令，没有返回值，一般用来执
行Runnable
Future submit(Callable task):执行任务，有返回值，一般又来执行Callable
void shutdown() :关闭连接池
Executors: 工具类、线程池的工厂类,用于创建并返回不同类型的线程池

posted @ 2021-09-10 20:29 17_Xtreme 阅读(33) 评论(0) 编辑收藏举报

刷新页面返回顶部

残羽