Java多线程

多线程

 创建线程的两种方式

//通过继承Thread来开发线程
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();//创建 Cat 对象，可以当做线程使用
        cat.start();//真正实现多线程的效果， 是 start0(), 而不是 run,/start0() 是本地方法，是 JVM 调用, 底层是 c/c++实现
        // 当 main 线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
        // 这时 主线程和子线程是交替执行..
        for (int i = 1; i <= 10; i++) {
            System.out.println("main线程");
            Thread.sleep(1000);
        }
        //Thread.currentThread().getName()可以获取线程名字
    }

}
class Cat extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("喵喵");
            try {//IDEA:ctrl+alt+t可快速生成try catch等函数
                Thread.sleep(1000);//当该线程执行到一个interrupt方法时，就会catch一个异常
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//通过实现 Runnable来开发线程
public class Thread02 {
    public static void main(String[] args) throws InterruptedException {
        Dog dog=new Dog();
        //没有dog.start()方法，在这里用不了！
        Thread thread=new Thread(dog);//静态代理模式
        thread.setDaemon(true);//将其设置为守护线程
        thread.start();
        for (int i = 1; i <= 10; i++) {
            System.out.println("main线程");
            Thread.sleep(1000);
        }
    }
}

class Dog implements Runnable{
    @Override
    public void run() {
        for(int i=1;i<=100;i++)
        {
            System.out.println("小狗汪汪叫");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程常用方法

注意：

 yield和join

 yield是Thread的静态方法

join使用：要插入的线程.join

用户线程和守护线程

 XXX.setDamo//将其设置为守护线程

 线程的生命周期

线程同步机制

 同步具体方法

public class syn {
    public static void main(String[] args) {
        SellTicket sell=new SellTicket();//保证了同一对象！！！！！！！！！！
        Thread thread01=new Thread(sell);
        Thread thread02=new Thread(sell);
        Thread thread03=new Thread(sell);
        thread01.start();
        thread02.start();
        thread03.start();

    }
}
class SellTicket implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    private boolean loop = true;//控制 run 方法变量
    Object object=new Object();

    public /*synchronized*/ void sell() throws InterruptedException { //同步方法, 在同一时刻， 只能有一个线程来执行 sell 方法
        //这时锁在 this 对象 , 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在 this 对象
        //同步方法（静态的）的锁为当前类本身
        synchronized (/*this*/object) {//同步代码块，与同步方法作用相同，new Object()的话就不是同一对象了
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }
            //休眠 50 毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票" + " 剩余票数=" + (--ticketNum));
        }


        
    }
    @Override
    public void run() {
        while (loop) {
            try {
                sell();//sell 方法是一同步方法
            } catch (InterruptedException interruptedException) {
                interruptedException.printStackTrace();
            }
        }
    }
}

 注意：

线程的死锁 

 释放锁

 2.下面操作不会释放锁

 线程通信

线程池的使用 

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

public class ThreadPool {
    public static void main(String[] args) {
        //创建线程池，newFixedThreadPool里的参数为线程池大小
        ExecutorService service= Executors.newFixedThreadPool(10);
        service.execute(new Eat());//service.execute可以执行一个Runnable的实现类,和start是一样的效果
        service.execute(new Eat());
        service.execute(new Eat());
        service.execute(new Eat());
        service.execute(new Eat());
        //关闭连接
        service.shutdown();
    }
}
class Eat extends Thread{
    @Override
    public void run() {
        for(int i=1;i<=5;i++)
        {
            System.out.println("线程"+Thread.currentThread().getName()+"在吃"+i+"个包子");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}