JAVA【多线程】

最新推荐文章于 2024-04-17 12:00:00 发布

爱吃小香葱

最新推荐文章于 2024-04-17 12:00:00 发布

阅读量87

点赞数 2

分类专栏： JAVA基础文章标签： java

本文链接：https://blog.csdn.net/huhuhutony/article/details/116675046

版权

JAVA基础专栏收录该内容

15 篇文章 0 订阅

订阅专栏

多线程的创建

方式一：继承Thread类

创建一个继承于Thread类的子类
重写Thread类的run()方法。将此线程执行的操作声明在run()中
创建Thread类子类的对象
通过此对象调用start()。 start()方法的作用：①启动当前线程②调用当前线程的run()方法

class MyThread extends Thread{
    @Override
    public void run(){
        for(int i = 0; i < 100; i++){
            if(i%2 == 0){
                System.out.println(i);   
            }
        }
    }
}
public class MyThreadTest{
    public static void main(String[] args){
        MyThread t1 = new MyThread();
        t1.start();
        //t1.run();不对！这样没有启动新的线程~！还是在主线程中 
        //t1.start(); //一个线程不可以start()两次，会报IllegalThreadStateException
         MyThread t2 = new MyThread();
         t2.start();//可以再new一个线程
        for(int i = 0; i < 100; i++){
            if(i%2 == 0){
                System.out.println(i + "****main()*****");   
            }
        }
    }
}
//简写：通过Thread的匿名子类的方式来创建线程
public class MyThreadTest1{
    public static void main(String[] args){
       new Thread(){
            @Override
            public void run(){
                for(int i = 0; i < 100; i++){
                    if(i%2 == 0){
                    System.out.println(Thread.currentThread().getName() + ":" + i);   
                    }
                }       
            }
        }.start();
    }
}

Thread类的一些方法

start() :启动当前线程、调用当前线程的run()方法
run() ：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
currentThread() :静态方法，返回执行当前代码的线程
getName() :获取当前线程的名字
setName() :设置当前线程的名字

public class MyThreadTest{
    public static void main(String[] args){
        MyThread t1 = new MyThread();
        t1.setName("线程一");
        //另一种给线程命名的方式：
         MyThread t2 = new MyThread("线程二");//重写Thread类的带参数的构造器
        Thread.currentThread().setName("主线程");//给主线程取名
        t1.start();
    }
}

yield() :释放当前线程对CPU的占用
join() :在线程a中调用b的join(),此时线程a就进入阻塞状态，直到线程b执行完毕，线程a才结束阻塞状态
sleep(long millitime) :让当前线程进入阻塞状态指定的millitime毫秒
isAlive() :判断当前线程是否存活

线程的调度

Java的调度策略：同优先级线程组成先进先出队列，使用时间片策略。对高优先级，使用优先调度的抢占式策略

线程的优先级

MAX_PRIORITY : 10
MIN_PRIORITY : 1
NORM_PRIORITY : 5 ->默认

获取和设置当前线程的优先级

getPriority()
setPriority(int p)

public class MyThreadTest{
    public static void main(String[] args){
        MyThread t1 = new MyThread();
        t1.setName("线程一");
        t1.setPriority(Thread.MAX_PRIORITY);//线程t1设为高优先级
        Thread.currentThread().setName("主线程");   
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);//主线程设为低优先级
        t1.start();
    }
}

高优先级的线程抢占CPU的概率更大

练习：三个窗口卖100张票

class Window extends Thread{
    
    private static int ticket = 100; 
    
    @Override
    public void run(){
        while(true){
            if(ticket > 0){
                System.out.println(gtName() + ":卖了一张票，票号为：" + ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}
//这个例子存在线程安全问题

创建多线程的方式二：实现Runable接口

创建一个实现Runable接口的类
实现类实现Runable中的抽象方法run()
创建实现类的对象
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
通过Thread类的对象去调用start()方法

class MyThread implements Runable{
    @Override
    public void run(){
        for(int i = 0; i < 100; i++){
            if(i%2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);   
            }
        }       
    }
}
public class MyThreadTest{
    public static void main(String[] args){
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread);
        t1.start();
        //再启动一个线程
        Thread t2 = new Thread(myThread);
        t2.start();
    }
}

使用第二种方式卖票

class Window implements Runable{
    
    private int ticket = 100;
    
    @Override
    public void run(){
        while(true){
            if(ticket > 0){
                System.out.println(gtName() + ":卖了一张票，票号为：" + ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}

public class WindowTest{
    public static void main(String[] args){
        Window window = new Window();
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);
        
        t1.start();
        t2.start();
        t3.start();
    }
}
//这次ticket不用声明为static的
//仍然存在线程安全问题待解决

两种创建多线程方式的对比

开发中优先选择实现Runable接口的方式

没有类的单继承的局限性
适合处理多个线程共享数据的情况（实现Runable接口的方式天然的拥有多线程共享数据的好处）
二者的联系：实际上Thread类也是实现了Runable接口，两种方式都需要重写run()

线程的生命周期
Thread.State类（枚举类）定义了线程的几种状态

新建：Thread类或其子类声明的对象创建之后，新生的线程对象处于新建状态
就绪：新建的线程对象调用start()方法之后，进入线程队列等待CPU时间片，此时线程即进入就绪状态
运行：就绪的线程被调度并获得CPU资源时，即进入运行状态，run()方法定义了线程的操作和功能
阻塞：特殊情况下CPU临时终止自己的执行，线程进入阻塞状态 sleep();、join();、等待同步锁、wait();、suspend();
死亡：线程完成全部工作，或线程提前强制性终止，或发生异常导致结束

线程的同步
解决前面遇到的线程的安全问题 - 错票、重票
多个线程执行的不确定性会引起执行结果的不稳定性
多个线程共享数据会造成操作的不完整性，会破坏数据
如何解决：当一个线程a在操作ticket时，其他线程不可参与进来，即使线程a出现了阻塞
JAVA中通过同步机制来解决这个问题
++方式一：同步代码块++

synchronized(同步监视器){   //同步监视器:俗称“锁”，任何一个类的对象都可以充当锁。
 //需要被同步的代码(操作共享数据的代码)
}

class Window implements Runable{
    private int ticket = 100;
    Object obj = new Object();
    
    @Override
    public void run(){
        while(true){
            synchronized(obj){
                if(ticket>0){
                
                    try{
                        Thread.sleep(1000);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    
                    System.out.println(gtName() + ":卖了一张票，票号为：" + ticket);
                    ticket--;    
                }else{
                    break;
                }
            }
        }
    }
}

操作共享数据的代码即为需要被同步的代码
共享数据：多个线程共同操作的变量
同步监视器:俗称“锁”，任何一个类的对象都可以充当锁。
关于obj：要求多个线程必须共用同一把锁

//使用同步代码块解决继承Thread类的方式的线程安全问题
class Window extends Thread{
    
    private static int ticket = 100; 
    private static Object obj = new Object();
    
    @Override
    public void run(){
        synchronized(obj){
            while(true){
                if(ticket > 0){
                    System.out.println(gtName() + ":卖了一张票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }    
    }
}

实现Runable接口的方式可以使用现成的"锁":this

class Window implements Runable{
    private int ticket = 100;
    //Object obj = new Object();
    
    @Override
    public void run(){
        while(true){
            //synchronized(obj){
            synchronized(this){
                if(ticket>0){
                
                    try{
                        Thread.sleep(1000);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    
                    System.out.println(gtName() + ":卖了一张票，票号为：" + ticket);
                    ticket--;    
                }else{
                    break;
                }
            }
        }
    }
}

继承Thread类的方式也可以有一种简单的"锁"

class Window extends Thread{
    
    private static int ticket = 100; 
    private static Object obj = new Object();
    
    @Override
    public void run(){
        //synchronized(obj){
        synchronized(Window.class){ //后面学了反射再理解
            while(true){
                if(ticket > 0){
                    System.out.println(gtName() + ":卖了一张票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }    
    }
}

++方式二：同步方法++
++如果操作共享数据的代码完整地声明在一个方法中，我们不妨将此方法声明为同步的！++

//使用同步方法解决实现Runable接口的线程安全问题
class Window implements Runable{
    
    private int ticket = 100;
    
    private synchronized void show(){   //同步监视器：this
        if(ticket > 0){
            try{
                Thread.sleep(1000);
            }catch(InterruputedException e){
                e.printStackTrace;
            }
            System.out.println(gtName() + ":卖了一张票，票号为：" + ticket);
            ticket--;
        }
    }
    
    
    @Override
    public void run(){
        while(true){
            show();
        }    
    }
}

public class WindowTest{
    public static void main(String[] args){
        Window window = new Window();
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);
        
        t1.start();
        t2.start();
        t3.start();
    }
}

//使用同步方法解决继承Thread类方式中的线程安全问题
class Window extends Thread{
    
    private static int ticket = 100; 
    
    private static synchronized void show(){    //同步监视器：Window.class
    //private synchronized void show(){  同步监视器：this（t1,t2,t3） 锁不唯一，不对
        if(ticket > 0){
            try{
                Thread.sleep(1000);
            }catch(InterruputedException e){
                e.printStackTrace;
            }            
            System.out.println(Thread.currentThread.gtName() + ":卖了一张票，票号为：" + ticket);
            ticket--;
        }
    }
    
    @Override
    public void run(){
        while(true){
            show();
        }
    }
}
public class WindowTest{
    public static void main(String[] args){
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();
        
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        
        t1.start();
        t2.start();
        t3.start();
    }
}

关于同步方法的总结：

同步方法仍然涉及到同步监视器，只是不需要我们显式地声明。
非静态的同步方法，同步监视器是this
静态的同步方法同步监视器是当前类本身

使用同步机制将单例模式中的懒汉式改写为线程安全的

class Bank{
    private Bank(){}
    
    private static Bank instance = null;
    
    public static Bank getInstance(){
        if(instance == null){
            instance = new Bank();
        }
        return instance;
    }
}
//线程安全的方式一：
class Bank{
    private Bank(){}
    
    private static Bank instance = null;
    
    public static synchronized Bank getInstance(){
        if(instance == null){
            instance = new Bank();
        }
        return instance;
    }
}
//线程安全的方式一`：
class Bank{
    private Bank(){}
    
    private static Bank instance = null;
    
    public static  Bank getInstance(){
        synchronized(Bank.class){
            if(instance == null){
                instance = new Bank();
            }
            return instance;
        }    
    }
}
//线程安全的方式二：  效率更高
class Bank{
    private Bank(){}
    
    private static Bank instance = null;
    
    public static Bank getInstance(){
        if(instance == null){
            synchronized(Bank.class){
                if(instance == null){
                    instance = new Bank();
                }
            }  
        }
        return instance;
    }
}

线程的死锁问题
不同的线程都在等待对方占用的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
出现线程死锁后不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

//死锁举例
public class ThreadTest{
    public static void main(String[] args){
        StringBuffer s1 =  new StringBuffer;
        StringBuffer s2 =  new StringBuffer;
        
        new Thread(){
            @Override
            public void run(){
                synchronized(s1){
                    s1.append("a");
                    s2.append("1");
                    
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace;
                    }
                    
                    synchronized(s2){
                        s1.append("b");
                        s2.append("2");
                    }
                }
            }
        }.start();
        
        new Thread(new Runnable(){
            @Override
            public void run(){
                synchronized(s2){
                    s1.append("c");
                    s2.append("3");
                    
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace;
                    }
                    
                    synchronized(s1){
                        s1.append("d");
                        s2.append("4");
                    }
                }
            }
        }).start();
    }
}

解决死锁的办法：

专门的算法、原则
尽量减少同步资源的定义
尽量避免嵌套同步

解决线程安全问题的方式三 --Lock锁，JDK5.0新增的更强大的线程同步机制
通过显式调用同步锁对象来实现同步，同步锁使用lock对象充当。
java.util.concurrent.locks.lock接口是控制多个线程对共享资源进行访问的工具
锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应该先获得lock对象
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用，它可以显式加锁、释放锁

class Window implements Runnable{
    private int ticket = 100；
    
    private ReentrantLock lock = new ReentrantLock();   //创建lock对象
    
    @Override
    public void run(){
        while(true){
            try{
                
                lock.lock();    //加锁
                
                if(ticket > 0){
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    
                    System.out.println(Thread.currentThread().getname() +":售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
                
            }finally{
                lock.unlock();  //解锁
            }
        }
    }
}

synchronized与lock这两种方式的异同

相同点：都是解决线程的同步问题的
不同点：synchronized机制在执行完相应的同步代码块之后，自动地释放同步监视器；lock需要手动地启动同步（lock.lock();）和手动地结束同步（lock.unlock();）

优先使用顺序：Lock --> 同步代码块（已经进入了方法体，分配了相应资源） --> 同步方法（在方法体之外）
面试题：如何解决线程的安全问题？有几种方式？
练习两个储户分别向同一个账户存3000元，每次存1000，存3次，每次存完打印账户余额

class Account{
    public double ballance;
    
    public Account(double ballance){
        this.ballance = ballance;
    }
    
    public synchronized void deposit(double amt){
        if(amt > 0){
            ballance += amt;
            
            Thread.sleep(1000);
            
            System.out.println(Thread.currentThread().getName() + "存钱成功，余额为：" + ballance);
        }
        
    }
}

class Customer extends Thread{
    private Account acct;
    
    publlic Customer(Account acct){
        this.acct = acct; 
    }
    
    @Override
    public run(){
        for(int i = 0;i < 3; i++){
            acct.deposit(1000);
        }
    }
}

public class AccountTest{
    public static void main(String[] args){
        Account acct = new Account(0);
        Customer c1 = new Customer(acct);
        Customer c2 = new Customer(acct);
        c1.setName("甲");
        c2.setName("乙");
    }
}

线程的通信（几个方法的使用）
例：使用两个线程交替打印1~100

class Number implements Runnable{
    private int number = 1;
    @Override
    public void run(){
        while(true){
            synchronized(this){
                
                notify();//唤醒阻塞状态的线程
                //省略了this，其实是this.notify();
                try{
                    Thread.sleep(10);
                }catch(InterruptException){
                    e.printStackTrace();
                }
                
                
                if(number <= 100){
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    
                    wait();//进入阻塞状态且当前线程释放锁
                    //省略了this，其实是this.wait();
                    
                }else{
                    break;
                }
            }    
        }
    }
}
public class CommunicationTest{
    public static void main(String[] args){
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);
        
        t1.setName("线程1");
        t2.setName("线程2");
        
        t1.start();
        t2.start();
    }
}

wait(); 一旦执行此方法，当前线程进入阻塞状态并且释放锁
notify(); 一旦执行此方法，唤醒被wait()的线程，优先唤醒优先级最高的
notifyAll(); 一旦执行此方法，唤醒所有被wait()的线程

说明：

这三个方法的调用只能出现的同步代码块或同步方法中。
这三个方法的调用者必须是同步代码块或同步方法中的同步监视器否则会出现IllegalMonitorStateException异常

class Number implements Runnable{
    private int number = 1;
    private Object obj = new Object();
    @Override
    public void run(){
        while(true){
            synchronized(obj){
                
                obj.notify();//调用者必须是同步监视器
                
                try{
                    Thread.sleep(10);
                }catch(InterruptException){
                    e.printStackTrace();
                }
                
                
                if(number <= 100){
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    
                    obj.wait();//调用者必须是同步监视器
                   
                    
                }else{
                    break;
                }
            }    
        }
    }
}

这三个方法是定义在Object类中的！

面试题：

sleep()和wait()方法的异同：
相同点：一旦执行都可以使当前线程进入阻塞状态；
不同点：①两个方法声明的位置不同，sleep()声明在Thread类中，wait()声明在Object类中②调用的要求不同，sleep()可以在任何需要的场景下使用，wait()必须使用在同步代码块或同步方法中③关于是否释放同步监视器：如果都在同步代码块或同步方法中调用，sleep()不会释放同步监视器，wait()会释放同步监视器。

经典例题：生产者消费者问题
生产者(Productor)将产品交给店员(CLerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产，如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

class Clerk{
    private int productCount = 0;
    
    public synchronized void poduceProduct(){
        if(productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + "开始生产第" + productCount + "个产品");
            notify();
        }else{
            try{
                wait();
            }catch(InterruptException e){
                e.printStackTrace();
            }
        }
    }
    public synchronized void consumeProduct(){
        if(productCount > 0){
            System.out.println(Thread.currentThread().getName() + "开始生产第" + productCount + "个产品");
            productCount--;
            notify();
        }else{
            try{
                wait();
            }catch(InterruptException e){
                e.printStackTrace();
            }
        }
    }
}

class Producer extends Thread{
    private Clerk clerk;
    
    public Producer(Clerk clerk){
        this.clerk = clerk;
    }
    
    @Override
    public void run(){
        clerk.produceProduct();
    }
}

class Consumer extends Thread{
    private Clerk clerk;
    
    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }   
    
    @Override
    public void run(){
         clerk.consumeProduct();
    }
}

public class ProductTest{
    public static void main(String[] args){
    Clerk clerk = new Clerk();
    Producer p1 = new Producer(clerk);
    p1.setName("生产者1");
    Consumer c1 = new Consumer(clerk);
    c1.setName("消费者1");
    
    p1.start();
    c1.start();
        
    }
}

JDK5.0新增的线程创建方式
新增方式一：实现Callable接口
相比run()方法，可以有返回值；方法可以抛出异常；支持泛型的返回值；需要借助FutureTask类，比如获取返回结果。

//1.创建一个实现Callable接口的实现类
class NumThread implements Callable{
    int sum = 0;
    //2.重写call()，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception{
        for(int i = 0; i <= 100; i++){
            if(i % 2 == 0){
                sum += i;
            }
        }
        return sum;//自动装箱
    }
}


public class ThreadNew{
    public static void main(String[] args){
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futuretask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，并调用start()
        new Thread(futuretask).start();
        //6.(可省略)获取Callable中call方法的返回值  
        try{
            Object sum = futureTask.get();//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            System.out.println("总和为:" + sum);
        }catch(InterruptException e){
            e.printStackTrace();
        }catch(ExecutionException e){
            e.printStackTrace();
        }
    }
}

如何理解实现Callable接口的方式创建多线程比实现Runnable接口的方式更强大？

call()可以有返回值
call()可以抛出异常，被外面的操作捕获，获取异常信息
Callable支持泛型

新增方式二：使用线程池（开发中都是用线程池的！）
背景：经常创建和销毁使用量特别大的资源，比如并发情况下的线程，对性能影响很大
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回线程池中。可以避免频繁创建、销毁，实现重复利用，类似生活中的公共交通工具。
好处：提高响应速度、降低资源消耗、便于线程管理
线程池相关API：ExecutorService和Executor
ExecutorService：真正的线程池接口，常见子类：ThreadPoolExecutor
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

class NumThread implements Runnable{
    @Override
    public void run(){
        for(int i = 0; i < = 100; i++){
            if(i % 2){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadPool{
    public static void main(String[] args){
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //设置线程池的属性，便于线程管理
        //ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;
        //service1.setCorePoolSize(15);
        
        //2.执行指定的线程的操作。需要提供实现Runnable或者Callable接口的实现类的对象
        service.execute(new NumberThread());
        service.execute(new NumberThread1());//execute()适合于Runnable接口 submit()适合于Callable接口
        //3.关闭线程池
        service.shutdown();
    }
}