多线程-多线程创建和安全问题的解决

最新推荐文章于 2022-08-24 21:09:10 发布
最新推荐文章于 2022-08-24 21:09:10 发布
阅读量164 收藏
点赞数
文章标签： 多线程 synchronized 线程安全 线程池 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46074155/article/details/116566625
版权

一、多线程的创建

方式一：继承Thread

案例：
如主线程查询10以内所有的奇数，分线程0查询10以内所有的偶数，分线程1输出hello world

/**
 * 步骤：
 * 1.创建一个继承于Thread类的于类
 * 2.重写Thread类的run(),方法体写要做的事
 * 3.创建Thread类的子类的对象
 * 4.通过此对象调用start():①启动当前线程②调用当前线程的run()方法
 */
public class MyThreadTest {
    public static void main(String[] args){
        //创建Thread类的子类的对象thread0和thread1
        MyThread0 thread0 = new MyThread0();
        MyThread1 thread1 = new MyThread1();
        //通过对象调用start()
        thread0.start();
        thread1.start();
        //main()方法是一个线程，run()方法是另一个线程

        /*注意：不能直接调用run()方法启动线程，此时全都是主线程
        如果还想再创建一个线程，不能直接调用thread.start()方法，会报IllegalThread异常，则需要重新创建一个对象，再去调用start（）
        MyThread thread1 = new MyThread();
        thread1.start();
         */


        //主线程
        for (int i=0; i<10;i++){
            if (i%2 != 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }

    }
}

//创建一个继承于Thread类的子类MyThread0，用来查询查询100以内所有的偶数（分线程0）
class MyThread0 extends Thread{
    //重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }

}


//新创建一个继承于Thread类的子类MyThread1，用来查询查询100以内所有的偶数（分线程1）
class MyThread1 extends Thread{
    //重写Thread类的run()
    @Override
    public void run() {
        for(int i =0;i<5;i++) {
            System.out.println(Thread.currentThread().getName() + ":hello world"+i);
        }
    }

}

结果：
在这里插入图片描述

方式二：实现Runnable接口

代码：

package Thread;
/**
 步骤：
 1.创建一个实现了Runnable接口的类
 2.实现类去实现Runnable中的抽象方法: run()
 3.创建实现类的对象
 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 5.通过Thread类的对象调用start()
 */

//1.创建一个实现了Runnable接口的类
class MyThread implements Runnable {
    //2.实现类去实现Runnable中的抽象方法: run(),调用了Runnable类型的target的run（）
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
public class MyThreadTest3 {
        public static void main(String[] args){
            //3.创建实现类的对象
            MyThread myThread = new MyThread();
            //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
            Thread thread0 = new Thread(myThread);
            //5.通过Thread类的对象调用start()
            thread0.setName("线程1");
            thread0.start();
            //再启动一个线程，查询10以内的偶数
            Thread thread1 = new Thread(myThread);
            thread1.setName("线程2");
            thread1.start();


        }
}

结果：
在这里插入图片描述

方式三：实现Callable接口—JDK 5.0 新增

Future接口
1.可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
2.FutureTask是Future接口的唯一的实现类
3.FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

代码：


package Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 步骤：
 1.创建一个实现callable接口的实现类
 2.实现call方法，将此线程需要执行的操作声明在call()中
 3.创建Callable接口实现类的对象
 4.将Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask对象
 5.将FutureTask对象作为参数传递到Thread构造器中，匿名创建Thread，并调用start()方法
 6.获取Callable中call方法的返回值
 */

//1.创建一个实现callable接口的实现类
class NewThead implements Callable{

    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {

        //求和
        int sum = 0;

        System.out.println("100以内所有奇数有:");
        //遍历100以内的奇数
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(i);
                sum += i;
            }
        }
        //call()方法可以有返回值
        return sum;
    }
}
public class CreateNewThead3 {
    public static void main(String[] args)  {
        //3.创建Callable接口实现类的对象
        NewThead newThead = new NewThead();

        //4.将Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask对象
        FutureTask futureTask = new FutureTask(newThead);

        //5.将FutureTask对象作为参数传递到Thread构造器中，匿名创建Thread，并调用start()方法
         new Thread(futureTask).start();


        //6.获取Callable中call方法的返回值
        //调用get()方法
        try {
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("100以内所有奇数的和为:"+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }


    }
}

部分截图：
在这里插入图片描述

方式四：使用线程池—JDK 5.0 新增

思路：
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。

优点：

  • ➢提高响应速度(减少了创建新线程的时间)
  • ➢降低资源消耗(重复利用线程池中线程，不需要每次都创建)
  • ➢便于线程管理

代码：

package Thread;

/**
 步骤：
 1.创建指定数量线程的线程池
 2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
 3.关闭线程池

 */

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


class NumThead implements Runnable{

    @Override
    public void run() {
        //遍历100以内的奇数
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}


class NumThead1 implements Runnable{

    @Override
    public void run() {
        //遍历100以内的偶数
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class CreateNewThead4 {
    public static void main(String[] args){

        //1.创建指定数量线程的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //service1为接口，里面属性都是常量，不能设置，所以需要强转为ThreadPoolExecutor类型
        //ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;

        //设置线程的属性
        //service1.setCorePoolSize(15);//核心池的大小

        //提交方法
        //service.submit(numThead);适用于callable接口

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumThead());//适用于runnable接口
        service.execute(new NumThead1());


        //3.关闭线程池
        service.shutdown();

    }
}

部分结果：
在这里插入图片描述

二、不同创建方法之间的比较

1. 比较继承Thead和实现runnable接口。
联系: public class Thread implements Runnable
相同点:两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

开发中:优先选择:实现Runnable接口的方式
原因: 1.实现的方式没有类的单继承性的局限性 2.实现的方式更适合来处理多个线程有共享数据的情况。

2.如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?
①call()可以有返回值的。
②call()可以抛出异常，被外面的操作捕获，获取异常的信息
③ Callable是支持泛型的

三、线程安全

案例：
1.问题:卖票过程中，出现了重票、错票–>出现了线程的安全问题，即多个线程共享数据
2.问题出现的原因:当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
3.如何解决:当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
4.在Java中，我们通过同步机制，来解决线程的安全问题。
5.同步的方式，解决了线程的安全问题。—好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

（一）出现原因：
多个线程共享数据时，当某个线程没有执行完，而第二个线程又开始执行，这时就出现了线程的安全问题，

（二）解决方式：

方式一：同步代码块

 synchronized(同步监视器){
 *           //需要被同步的代码
 *              }

synchronized

 @Override
    public void run() {
            while (true) {
                //this为当前对象，因为只有一个windows对象
                synchronized (this){//synchronized (obj) {
                if (ticket > 0) {
                    //线程共享概率增大，可加睡眠时间
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }

    }

全代码：

class SaleTickets implements Runnable{

    //只有一个对象，所以不用加static
    private  int ticket = 100;
    //Object obj = new Object();//任意对象充当锁


    @Override
    public void run() {
            while (true) {
                //this为当前对象，因为只有一个windows对象
                synchronized (this){//synchronized (obj) {
                if (ticket > 0) {
                    //线程共享概率增大，可加睡眠时间
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }

    }
}
public class SaleTicket2 {
    public static void main(String[] args){
        SaleTickets windows = new SaleTickets();

        Thread w1 = new Thread(windows);
        Thread w2 = new Thread(windows);
        Thread w3 = new Thread(windows);

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();

    }

}

部分截图：
在这里插入图片描述

方式二:同步方法

synchronized锁

 //方式二:同步方法解决线程安全问题，show方法中全是共享数据
        public synchronized void show(){//this唯一，所以同步监视器为this
                if (ticket > 0) {
                    //线程共享概率增大，可加睡眠时间
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                }
            }

全代码：

package Thread;


    class SaleTickets2 implements Runnable{

        //只有一个对象，所以不用加static
        private  int ticket = 100;
        //Object obj = new Object();//任意对象充当锁


        @Override
        public void run() {//不能给run方法加锁，必须方法中全是共享数据
            while (true) {
                show();
            }

        }
        //方式二:同步方法解决线程安全问题，show方法中全是共享数据
        public synchronized void show(){//this唯一，所以同步监视器为this
                if (ticket > 0) {
                    //线程共享概率增大，可加睡眠时间
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                }
            }
    }


public class SaleTicket3 {
        public static void main(String[] args){
            SaleTickets2 windows2 = new SaleTickets2();

            Thread w1 = new Thread(windows2);
            Thread w2 = new Thread(windows2);
            Thread w3 = new Thread(windows2);

            w1.setName("窗口1");
            w2.setName("窗口2");
            w3.setName("窗口3");

            w1.start();
            w2.start();
            w3.start();

        }

    }

部分截图：
在这里插入图片描述
在这里插入图片描述
方式三：使用Lock锁— JDK5.0新增

1.实例化ReentrantLock，ReentrantLock实现了Lockprivate

ReentrantLock reentrantLock = new ReentrantLock(true);

2.将同步代码块，放在try中

 try{
                //3.调用锁定lock()方法,启用同步监视器
                reentrantLock.lock();
                if (ticket > 0){
                    //增加线程死锁概率
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":售票，售票号为:"+ticket);
                    ticket--;
                }else {
                    break;
                }
            }finally {
                //4.调用解锁unlock()方法，关闭同步监视器
                reentrantLock.unlock();

            }

3.调用锁定lock()方法,启用同步监视器

       reentrantLock.lock();

4.调用解锁unlock()方法，关闭同步监视器

        reentrantLock.unlock();

全代码：

class Window implements Runnable{
    private int ticket = 100;
    //1.实例化ReentrantLock，ReentrantLock实现了Lock
    private ReentrantLock reentrantLock = new ReentrantLock(true);
    //公平lock，线程进出有顺序，避免一个线程一直抢占资源
    public void run() {
        //有余票
        while(true){
            //2.将同步代码块，放在try中
            try{
                //3.调用锁定lock()方法,启用同步监视器
                reentrantLock.lock();
                if (ticket > 0){
                    //增加线程死锁概率
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":售票，售票号为:"+ticket);
                    ticket--;
                }else {
                    break;
                }
            }finally {
                //4.调用解锁unlock()方法，关闭同步监视器
                reentrantLock.unlock();

            }


        }


    }
}
public class SiSuo {
    public static void main(String[] args){
        Window window = new Window();
        //创建三个窗口，即三个线程
        Thread w1 = new Thread(window);
        Thread w2 = new Thread(window);
        Thread w3 = new Thread(window);

        //设置线程名
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        //调用start（）方法
        w1.start();
        w2.start();
        w3.start();



    }


}

部分截图：
在这里插入图片描述
（三）优先使用顺序
Lock→同步代码块(已经进入了方法体，分配了相应资源)→同步方法(在方法体之外)

四、说明

1. synchronized与Lock的异同?
相同:synchronized与Lock都可以解决线程安全问题
不同: synchronized 机制在执行完相应的同步代码以后，自动释放同步监视器
Lock需要手动的启动同步(Lock()) ，同时结束同步也需要手动的实现(unlock())

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

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

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

五、线程通信

线程通信的应用:
经典例题:生产者/消费者问题

（1）实现runnable接口创建生产者线程，消费者线程

//共享数据
class Resource{
    //设置当前资源数量为0
    private int ResourceNum = 0;
    //设置上限为20
    private int ResourceMax = 20;

    //生产资源
    public synchronized void Produce() {
        //判断资源如果小于最大上限就开始生产资源
        if (ResourceNum < ResourceMax) {
            //增加生产资源数量
            ResourceNum++;
            System.out.println(Thread.currentThread().getName() + ":正在生产第" + ResourceNum + "个产品");
            //每当有资源增加就唤醒另一个消费资源的线程
            notify();
        }else{
            try {
                //如果资源达到上限该生产线程就阻塞，等待消费线程消费
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }


    //消费资源
    public  synchronized void Consume() {
        //判断如果资源有剩余就开始消费
        if (ResourceNum > 0) {
            System.out.println(Thread.currentThread().getName() + ":正在消费第" + ResourceNum + "个产品");
            //消费资源
            ResourceNum--;
            //每当资源有消费就唤醒另一个生产线程开始生产资源，当前的消费线程为阻塞
            notify();
        }else{
            //若没有资源，则阻塞，无法消费
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

//生产者
class Producer implements Runnable{
        //定义资源变量
        private Resource resource;


        public Producer(Resource resource) {
            this.resource = resource;
        }

        @Override
        public void run() {

            System.out.println(Thread.currentThread().getName()+"开始生产产品！！！！！！");
            //一直生产
            while(true){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                resource.Produce();
            }


        }


}

//消费者
class Consumer implements  Runnable{
        //定义资源变量
        private Resource resource;

        public Consumer(Resource resource) {
            this.resource = resource;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"开始消费产品！！！！！！");
            while(true){

                //增加交互概率
                try {
                    Thread.sleep(30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                resource.Consume();
            }

        }
    }
    public class ResourceTest{
        public static void main(String[] args){
        Resource resource = new Resource();
            //创建生产者线程
            Producer producer = new Producer(resource);
            Thread p1 = new Thread(producer);
            //创建消费者线程
            Consumer consumer = new Consumer(resource);
            Thread c1 = new Thread(consumer);

            //设置线程名
            p1.setName("生产者");
            c1.setName("消费者");

            //调用start()方法
            p1.start();
            c1.start();


    }
}

部分结果截图
在这里插入图片描述
（2）继承Thead类创建生产者线程，消费者线程

代码：

//共享数据
class Product{
    //创建当前产品数为0
    private int ProductNow = 0;
    //创建最大产品数上限为30
    private int ProductMax = 30;



    public synchronized void Product() {
        //如果当前产品数没有达到上限则开始生产
        if (ProductNow <ProductMax){

            ProductNow++;
            System.out.println(Thread.currentThread().getName()+"正在生产第"+ProductNow+"个产品");

            //每当产品数增加时，则唤醒另一个Consume线程，开始消费
            notify();

        }else{
            //当前产品数达到上限，则当前Product线程阻塞
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void Consume() {
        //产品有剩余，开始消费
        if (ProductNow > 0){

            System.out.println(Thread.currentThread().getName()+"正在消费第"+ProductNow+"个产品");
            ProductNow--;

            //每当有产品被消费时，则唤醒另一个Product线程，开始生产
            notify();

        }else{
            //产品没有剩余，当前Consume线程阻塞
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//生产者线程
class Producer0 extends Thread{
    //创建产品变量
    private Product product;

    public Producer0(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":已经开始生产产品！！！！！！");
        //一直生产
        while(true){
            //增加交互概率
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            product.Product();
        }

    }
}

//消费者线程
class Consumer0 extends Thread{
    //创建产品变量
    private Product product;

    public Consumer0(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":已经开始消费产品！！！！！！");
        //一直消费
        while(true){
            //增加交互概率
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            product.Consume();
        }

    }
}
public class ProductTest {
    public static void main(String[] args){
        Product product  = new Product();
        //创建生产者线程
        Producer0 p = new Producer0(product);
        //创建消费者线程
        Consumer0 c = new Consumer0(product);

        //更改线程名
        p.setName("生产者");
        c.setName("消费者");

        //调用start()方法
        p.start();
        c.start();


    }


}

部分截图
在这里插入图片描述

gougege0514
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程-解决单例模式中的懒汉式的线程安全问题
02-01
### Java多线程—解决单例模式中的懒汉式的线程安全问题 #### 一、单例设计模式的线程安全问题 ##### （1）饿汉式没有线程安全问题 **饿汉式**是一种非常典型的单例模式实现方式，其特点是在类加载时就完成了实例...
多线程学习之IllegalThreadStateException错误
doremyrainbow的博客
12-01 3989
刚开始学习多线程的时候出现了IllegalThreadStateException这个错误。 经检查发现是同一个线程不能多次执行start（）方法。 MyThread mt = new MyThread(); mt.start(); mt.start(); 主要是因为线程有四种状态 **1. 初始状态； 在调用start()方法之前 可运行状态； 调用start()方法后，系统为该线程分配除cpu外的所需资源，等待被线程调度选中，获取cpu 的使用权 。 运行状态 线程获得cpu执
IllegalThreadStateException解决
fxnfk
11-21 1万+
IllegalThreadStateException出错部分的源码： package thread;import java.util.Map;import org.apache.log4j.Logger;import com.pyc.redis.RedisClient; import com.pyc.redis.RedisKeyEnum; import com.pyc.service.PbbSe
Python3快速入门--Python3.9多线程编程
沐雪大神
04-02 1769
本文参考python官网：http://www.zyiz.net/tutorial/detail-6907.html https://docs.python.org/zh-cn/3.9/ 同时运行多个线程类似于同时运行多个不同的程序，但具有以下好处 - 进程内的多个线程与主线程共享相同的数据空间，因此可以比单独的进程更容易地共享信息或彼此进行通信。 线程有时也被称为轻量级进程，...
每天一个知识点- 线程池中线程执行任务发生异常会怎么样
1999的博客
08-24 1074
每天一个知识点- 线程池中线程执行任务发生异常会怎么样
Java提交到线程池（ExecutorService）中的代码出现异常了怎么操作
geforce
04-30 777
Java提交到线程池（ExecutorService）中的代码出现异常了怎么操作 先看看execute到线程池的问题 public static ThreadFactory spring() { return new CustomizableThreadFactory("spring-prefix-"); } /** * 创建只有1个线程的线程池 */ public static ExecutorService create(ThreadFactory t
Java多线程-JDK5.0新增线程创建方式
02-03
通过以上两个新增的线程创建方式，我们可以看到Java 5.0版本在多线程编程方面的改进和增强。使用`Callable`接口和线程池不仅提高了线程管理的灵活性，还增强了程序的可扩展性和性能表现。在实际开发过程中，根据具体...
Java多线程-生产者与消费者问题
02-03
### Java多线程-生产者与消费者问题 ...使用Java多线程技术，我们可以有效地解决这一问题，保证系统稳定运行。在实际应用中，还需要根据具体的业务需求调整和优化上述设计方案，以满足不同的并发控制需求。
Java多线程-多线程知识点总结和企业真题
最新发布
02-04
### Java多线程知识点总结及企业真题解析 #### 一、知识点总结 ##### （1）多线程相关概念 1. **程序、进程和线程的区分**： - **程序**：为了完成特定的任务而编写的指令集合。它是静态的概念。 - **进程**：...
Java多线程-线程间的通信
02-02
2. **解决线程安全问题**：由于两个线程需要共享同一个计数器变量`number`，因此需要对计数器的访问进行同步控制。 3. **等待和唤醒**：为了让两个线程能够交替打印数字，需要利用`wait()`和`notify()`方法。 **...
Java并发编程 —— 线程池
MercuryG的博客
06-15 1350
线程的缺点： 1、线程的创建需要开辟内存资源：本地方法栈、虚拟机栈、程序计数器等线程私有变量的内存。所以频繁的创建和消耗会带来一定的性能开销 2、使用线程不能友好的管理任务和友好的拒绝任务。在《阿里巴巴java开发手册》中要求，线程资源必须通过线程池提供，不允许在应用中自行显示创建线程。 线程池：   定义：使用池化技术来管理和使用线程的技术，就叫做线程池 线程池的创建方式包含7种 创建方式一：创建固定个数的线程池 package ThreadPool; import java.util.concu
ExecutorService线程池
HD243608836的博客
10-16 617
ExecutorService的submit和execute ExecuteService代表的是Executors创建的线程池①submit提交的是实现了Callable接口的方法，有返回值（返回Future，执行future.get()方法即可获取具体返回值）②execute执行的是实现了Runnable接口的方法，没有返回值所以线程池对象executorService选择使用submit和...
【121期】面试官问：线程池执行过程中遇到异常会发生什么，如何处理？
Java精选
09-24 532
点击上方“Java精选”，选择“设为星标”别问别人为什么，多问自己凭什么！下方留言必回，有问必答！每天08:00更新文章，每天进步一点点...线程遇到未处理的异常就结束了这个好理解，当...
线程 Thread ExecuteService ForkJoinPool 的笔记
gzhich的博客
10-21 214
jdk1.5前用 Thread jdk1.5出现了 ExecuteService 从接口的使用便利程度上远胜Thread,更不用说在java.util.concurrent包中的各种线程池，Future类和Lock等便利工具，由于ExecuteService是接口，面向接口编程的实现只需要实现该接口即可。 { private ExecuteService executeService; private int parallism; // 构造函数 public xxxx(){
Java 线程池的原理与实现
wuce7758的专栏
12-10 535
简单介绍    创建线程有两种方式：继承Thread或实现Runnable。Thread实现了Runnable接口，提供了一个空的run()方法，所以不论是继承Thread还是实现Runnable，都要有自己的run()方法。    一个线程创建后就存在，调用start()方法就开始运行（执行run()方法），调用wait进入等待或调用sleep进入休眠期，顺利运行完毕或休眠被中断或运行过程中出现
Java ExecutorService线程池中的小坑——关于线程池中抛出的异常处理
dingyuduan的专栏
01-04 1464
开发自己的项目有一段时间了，因为是个长时间跑的服务器端程序，所以异常处理显得尤为重要。 对于异常的抓取和日志（狭义上的日志）的分析一点都不能落下。 我们使用了Java自带的Executor模块，我只是稍微看了下Executors当中三个线程池的实现(策略为：Fixed, Cached, Schedule)，其实光看名字就可以了解各自的一些策略信息。OK，这一次我需要一种策略合并Fixed和C
java.lang.IllegalThreadStateException异常原因解析
热门推荐
lansesl2008的专栏
06-21 4万+
小白今天开始正式涉足多线程和队列，拍手拍手，欢庆欢庆.... ------------------------------------------------------------------------------------ 源代码如下： ThreadTest thread1 = new ThreadTest(); thread1.start(); thread1.start();
多线程（解决线程安全的3方法,Callable,Lambda）
文雯的博客
02-21 1162
????线程与进程 进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间。 线程是进程中的一个执行路径，共享一个内存空间，一个进程最少有一个线程，是对进程进一步划分 ✨当进程里面一个线程都没有时，该进程就被关闭了 例如：一个QQ音乐进程，拥有听歌显示图片刷评论等多个线程 分时调度： 为了能让每个线程均分CPU,一千多个线程快速轮流使用CPU的使用权，交替执行，给人造成一个假象好像多个任务同时在进行一样 Java使用的调度机制——抢占式调度： 哪个线程优先级高就先抢到CPU使用权概率大，优先级可以
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值