10. Java中创建多线程的4种方式及解决线程安全的3种方式

最新推荐文章于 2022-06-04 10:20:42 发布
最新推荐文章于 2022-06-04 10:20:42 发布
阅读量236 收藏
点赞数
分类专栏： Java学习 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38587510/article/details/116600411
版权

文章目录

线程、进程的相关知识看操作系统进行复习

多线程

一个java应用程序，其实至少有三个线程，一个main()主线程，一个异常处理线程，一个垃圾回收线程
java中创建线程的方式

1.继承于Thread类
2.通过实现Runable类
3.实现Callable接口（JDK5.0新增）
4.使用线程池（JDK5.0新增）

Java中多线程的创建方式
方式一：继承于Thread类
  • 1.创建一个继承Thread类的子类
  • 2.重写Thread类的run方法
  • 3.创建Thread类的子类的对象
  • 4.对象执行start方法
package com.senior.multithread;

/**
 * 多线程的创建：
 * 方式一：继承于Thread类
 * 1.创建一个继承Thread类的子类
 * 2.重写Thread类的run方法
 * 3.创建Thread类的子类的对象
 * 4.对象执行start方法
 *
 * @author eden
 * @create projectTest:2021-05-10-16:02
 */

public class TestMultiThread {
    public static void main(String[] args) {
        MyThread threadTest1 = new MyThread();
        //这里是分线程去做定义好的run方法体内的事情
        threadTest1.start();
        //再创建一个线程
        MyThread threadTest2 = new MyThread();
        threadTest2.start();
        //匿名子类的书写方式
        new Thread() {
            @Override
            public void run() {
                int sumOdd = 0;
                for (int i = 0; i < 100; i++) {
                    if (i % 2 != 0) {
                        sumOdd += i;
                    }
                }
                System.out.println(Thread.currentThread().getName() + ":" + "100以内的奇数和为" + sumOdd);

            }
        }.start();

        //sout这里是主线程在做事
        System.out.println(Thread.currentThread().getName() + ":" + "multithread Test");
    }
}


class MyThread extends Thread {
    public MyThread() {
    }

    @Override
    public void run() {
        int sumEven = 0;
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                sumEven += i;
            }
        }
        System.out.println(Thread.currentThread().getName() + ":" + "100以内的偶数和为" + sumEven);
    }
}

Thread类中的有关方法：

  1. void start() //启动线程，执行对象的run方法
  2. run() 线程被调度时所执行的操作
  3. String getName 返回线程的名称
  4. void setName(String name) 设置该线程的名称
  5. static Thread currentThread() 返回当前线程，在Thread子类中就是this，通常用于主线程和Runnable实现类 Thread.currentThread().getName() 得到当前线程的名称
  6. static void yield() 释放当前cpu的执行权。线程让步，暂停当前正在执行的线程，把执行机会让给优先级相同或者更高的线程；若队列中没有同优先级的线程，忽略此方法。
  7. join 当某个程序执行流中调用其他线程B的join方法时，调用线程A(可能是main线程)将被阻塞，直到join方法加入的join线程B执行完毕为止；低优先级的线程才可以获得执行
  8. static void sleep(long millis) 让当前活动线程在指定时间段内放弃对CPU的控制，使其他线程有机会被执行，时间到后重新进行排队。抛出InterruptedException异常
  9. stop() 强制线程生命周期结束，不推荐使用。 deprecated 已过时
  10. boolean isAlive() 返回boolean，判断线程是否还活着
package com.senior.multithread;

/**
 * 线程常用方法的测试
 *
 * @author eden
 * @create projectTest:2021-05-10-16:02
 */


public class TestMultiThread {
    public static void main(String[] args) {
        MyThread threadTest1 = new MyThread();
        //这里是分线程去做定义好的run方法体内的事情
        //设置线程名称
        threadTest1.setName("\033[1;95mThread" + threadTest1.getId() + "\033[0m:11sums of even up to 100");
        threadTest1.start();
        //再创建一个线程
        MyThread threadTest2 = new MyThread();
        threadTest2.setName("\033[1;95mThread" + threadTest2.getId() + ":\033[0msums of even up to 100");
        threadTest2.start();

        //匿名子类的书写方式
        new Thread() {
            @Override
            public void run() {
                int sumOdd = 0;
                for (int i = 0; i < 100; i++) {
                    if (i % 2 != 0) {
                        sumOdd += i;
                    }
                }
                System.out.println(Thread.currentThread().getName() + ":" + "100以内的奇数和为" + sumOdd);

            }
        }.start();

        int num = 2;
        HelloThread thread3 = new HelloThread();
        thread3.setName("\033[1;95mThread" + thread3.getId() + "\033[0m:hello world");
        if (num == 2) {
            try {
                threadTest2.join(); //需要进行异常处理
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        thread3.start();
        //sout这里是主线程在做事
        System.out.println(Thread.currentThread().getName() + ":" + "multithread Test");
        System.out.println(thread3.isAlive());
    }
}


class HelloThread extends Thread {
    @Override
    public void run() {
        System.out.println("Hello World Thread");
    }
}

class MyThread extends Thread {
    public MyThread() {
    }

    @Override
    public void run() {
        int sumEven = 0;
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                try {
                    sleep(1);  //sleep时会阻塞,单位ms
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                sumEven += i;
            }
            if (i % 20 == 0) {
                this.yield();//释放当前cpu的执行权
            }

        }
        System.out.println(Thread.currentThread().getName() + ":" + "100以内的偶数和为" + sumEven);
    }
}

output在这里插入图片描述

在这里插入图片描述
高优先级的线程会抢占低优先级的线程对CPU的控制权，但这并不意味着一定要等到高优先级的线程执行完之后低优先级的线程才可以执行。这仅仅是一个概率问题。

方式二：声明一个类实现Runnable方法

通过类实现Runable接口

  • 1.创建一个实现Runable接口的类
  • 2.实现类去实现Runable中的抽象方法run()
  • 3.创建实现类的对象
  • 4.将此对象作为作为参数传递到Thread类的构造器中，创建Thread类的对象
  • 5.Thread类的对象.start()
package com.senior.multithread;

/**
 * 创建多线程的方式二：
 * 通过类实现Runable接口
 * 1.创建一个实现Runable接口的类
 * 2.实现类去实现Runable中的抽象方法run()
 * 3.创建实现类的对象
 * 4.将此对象作为作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5.Thread类的对象.start()
 *
 * @author eden
 * @create projectTest:2021-05-10-18:42
 */
public class TestCreatMultiThread {
    public static void main(String[] args) {
        MyThreadWay tmp = new MyThreadWay();
        Thread th = new Thread(tmp);
        th.start();

        Thread th2 = new Thread(tmp);
        th2.start();
    }
}

class MyThreadWay implements Runnable {

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

案例对比：

三个窗口卖10张票，通过多线程实现。先给出两种简单的实现方式。
注意：下述两种方式是一个简易demo，其中都存在线程安全的问题，当前对比的操作是为了更好的理解通过继承Thread和实现Runable接口两种创建多线程的方式的特点。注意其中的ticks的类型。


package com.senior.multithread;

/**
 * 三个窗口买票，总票数是10张。
 *
 * @author eden
 * @create projectTest:2021-05-10-17:49
 */
public class SellTicketsTest {
    public static void main(String[] args) {
        SellTickets windows1 = new SellTickets();
        SellTickets windows2 = new SellTickets();
        SellTickets windows3 = new SellTickets();

        windows1.setName("SellTickets--Windows"+windows1.getId());
        windows2.setName("SellTickets--Windows"+windows2.getId());
        windows3.setName("SellTickets--Windows"+windows3.getId());

        windows1.start();
        windows2.start();
        windows3.start();

//        System.out.println("今日票已卖完！");
    }
}


class SellTickets extends Thread {
    //对于继承Thread方式实现多线程来说
    //由于每新开一个线程都需要new一个子类的对象，
    //对于这个例子来说，就相当于tickets在内存中存在了三份，
    //为了解决这个问题就需要将变量设置为static的
    //后续讲到的通过实现Runable接口方式就不需要考虑这个问题
    //因为其只需要声明一个实现接口类的对象即可
    private static int tickets = 10;

    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                System.out.println("\033[0;96m"+this.getName()+"\033[0m"+"//票号为："+tickets);
                --tickets;
            } else {
                break;
            }
        }
    }
}

package com.senior.multithread;

/**
 * 三个窗口买票，总票数是10张。
 *
 * @author eden
 * @create projectTest:2021-05-10-17:49
 */
public class SellTicketsTest {
    public static void main(String[] args) {
        SellTickets tmp = new SellTickets();

        Thread windows1 = new Thread(tmp);
        Thread windows2 = new Thread(tmp);
        Thread windows3 = new Thread(tmp);

        windows1.setName("SellTickets--Windows"+windows1.getId());
        windows2.setName("SellTickets--Windows"+windows2.getId());
        windows3.setName("SellTickets--Windows"+windows3.getId());

        windows1.start();
        windows2.start();
        windows3.start();

//        System.out.println("今日票已卖完！");
    }
}


class SellTickets implements Runnable {
    //通过实现Runable接口方式不需要考虑这个问题
    //因为其只需要声明一个实现接口类的对象即可，因此无需将其设置为static
    private int tickets = 10;

    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                System.out.println("\033[0;96m"+Thread.currentThread().getName()+"\033[0m"+"-->票号为："+tickets);
                --tickets;
            } else {
                break;
            }
        }
    }
}

比较上述两种方式：

开发中优先选择通过实现Runable的方式来进行多线程
原因：
1.实现的方式没有类的单继承的局限性
2.实现的方式更适合多线程处理有共享数据的情况

线程的生命周期
在这里插入图片描述

方式三：实现Callable接口 （JDK5.0新增）

步骤

  • 1.创建一个callable的实现类，重写call方法
  • 2.实现call方法，将需要执行的操作声明在call()中
  • 3.借助FutureTask类构造一个对象，将callable实现类的对象
  • 作为参数传递给FutureTask的构造器中
  • 4.借助Thread类创建一个线程对象并start
  • 5.可通过FutureTask对象的get()返回Callable实现类对call方法重写的返回值

如何理解与使用Runnable相比， Callable功能更强大些？

  • 1.call()可以有返回值。
  • 2.call()可以抛出异常，被外面操作捕获，获取异常信息。
  • 3.Callable支持泛型
    在这里插入图片描述
    在这里插入图片描述
package com.senior.multithread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 通过实现Callable接口创建线程
 * 实现Callable的类需要重写call方法
 *
 * @author eden
 * @create projectTest:2021-05-11-10:27
 */
public class CreateThread {
    public static void main(String[] args) {
        ThreadNewCall tmp = new ThreadNewCall();
        FutureTask futureTask = new FutureTask(tmp);
        new Thread(futureTask).start();

        try {
            //FutureTask对象的get()返回的是Callable实现类对call方法重写得到的返回值
            Object sum = futureTask.get();
            System.out.println("100以内的偶数和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}


class ThreadNewCall implements Callable {
    @Override
    public Object call() throws Exception {
        int sumEven = 0;
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                sumEven += i;
            }
        }
        return sumEven;
    }
}
方式四：使用线程池

在这里插入图片描述
在这里插入图片描述
以创建固定线程数量线程池为例：
1.创建一个固定数量的线程池
2.执行指定线程的操作，提供实现Runable或Callable接口的类对象
3.关闭线程池

其他注意事项仔细看代码注释

package com.senior.multithread;

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

/**
 * 创建线程方式四：使用线程池
 *
 * @author eden
 * @create projectTest:2021-05-11-10:58
 */
public class CreateThreadNew {
    public static void main(String[] args) {
        //1.创建一个固定数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        //可设置线程池属性：
        //注意：ExecutorService实际上仅仅是一个接口，没有办法直接通过service.**设置相关属性
        //因此需要找的是一个ExecutorService实现类，
        //System.out.println(service.getClass());通过这句代码，得到其类为ThreadPoolExecutor
        //然后就可以强转并进行设置
//        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//        service1.setMaximumPoolSize(20);

        //2.执行指定线程的操作，提供实现Runable或Callable接口的类对象
        service.execute(new ThreadNewCallNew1()); //适用于Runable
        service.execute(new ThreadNewCallNew2()); //适用于Runable
//        service.submit(); //适用于Callable

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

    }
}

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

class ThreadNewCallNew2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}
Java中通过同步机制来解决线程安全问题
方式一： 同步代码块

关于实现同步过程中的注意事项直接看demo中的注释即可，注释很全

package com.senior.multithread;
/**
 * 三个窗口卖票，总票数是1000张。
 * 问题：卖票过程中出现重票、错票 -->出现了线程安全问题
 * 解决方案：当一个线程在操作ticket时，其他线程不能参与进来
 *         直到当前线程操作结束之后，其他线程才可进入（在这种
 *         情况下，即使当前线程阻塞了，其他线程也无法进入）
 *---------------------------------------------------
 * Java中通过同步机制来解决线程安全问题：
 * 方式一： 同步代码块
 *      synchronized(同步监视器){
 *          //需要被同步的代码（操作共享数据的代码即为需要被同步的代码）
 *      }
 *      1.多个线程共同操作的数据即为共享数据
 *      2.同步监视器/信号量：锁。任何一个类的对象都可以充当锁。
 *       要求：多个线程必须共同同一个锁，也就是必须共用同一个充当信号量的类的对象（重要）
 *
 *       补充：在实现Runable接口的多线程方法中，可以考虑使用this充当同步监视器/信号量
 *            在继承Thrend的多线程方法中，可以考虑使用当前类(类名.class)作为同步监视器/信号量
 *同步代码块：解决了线程安全问题----好处
 *          但在操作同步代码块时，只能有一个线程运行，相当于是单线程，效率低 ----局限性
 *---------------------------------------------------
 * @author eden
 * @create projectTest:2021-05-10-17:49
 */
public class SellTicketsTest {
    public static void main(String[] args) {
        SellTickets tmp = new SellTickets();

        Thread windows1 = new Thread(tmp);
        Thread windows2 = new Thread(tmp);
        Thread windows3 = new Thread(tmp);

        windows1.setName("SellTickets--Windows"+windows1.getName());
        windows2.setName("SellTickets--Windows"+windows2.getName());
        windows3.setName("SellTickets--Windows"+windows3.getName());

        windows1.start();
        windows2.start();
        windows3.start();

    }
}


class SellTickets implements Runnable {
    //通过实现Runable接口方式不需要考虑这个问题
    //因为其只需要声明一个实现接口类的对象即可，因此无需将其设置为static
    private int tickets = 1000;
    //obj放在这里是线程安全的
    //分析：通过实现Runable的类之后创建一个该类对象selltickets
    //接着创建的Thread类的对象都使用该对象selltickets
    //而多个selltickets对象只有一个obj即共用一把锁，因此线程安全
    Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (tickets > 0) {
                    //sleep之后出现错票（比如票号为-1 0）的概率大大增大
                    //理想情况应该是没有
                    //简单描述：假设当前只剩一张票，即tickets=1
                    //A进程进入到这里之后，由于sleep所以进入阻塞状态
                    //此时tickets并未--，因此如果此时B进程进行判断，满足条件
                    //B进程也会进入到这里，接着两个进程都等待sleep时间到，A进程先出
                    //则ticket--为0，B进程再出时ticket--为-1
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println("\033[0;96m" + Thread.currentThread().getName() + "\033[0m" + "-->票号为：" + tickets);
                    --tickets;
                } else {
                    break;
                }
            }
        }
    }
}
方式二：同步方法
package com.senior.multithread;

/**
 * 多线程的线程安全问题解决
 * 方式二：同步方法
 *      定义：如果操作共享数据的代码完整的声明在一个方法中，我们不妨将这个方法声明为同步的。
 * @author eden
 * @create projectTest:2021-05-10-21:22
 */
public class SellTicketsTest2 {
    public static void main(String[] args) {
        SellTickets2 tmp = new SellTickets2();

        Thread windows1 = new Thread(tmp);
        Thread windows2 = new Thread(tmp);
        Thread windows3 = new Thread(tmp);

        windows1.setName("SellTickets--Windows"+windows1.getName());
        windows2.setName("SellTickets--Windows"+windows2.getName());
        windows3.setName("SellTickets--Windows"+windows3.getName());

        windows1.start();
        windows2.start();
        windows3.start();
    }
}

class SellTickets2 implements Runnable {

    private int tickets = 1000;

    @Override
    public void run() {
        //这个问题不适合直接将run声明为synchronized，因为包含的内容有冗余
        while (true) {
            show();
        }
    }

    private synchronized void show(){
        if (tickets > 0) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("\033[0;96m" + Thread.currentThread().getName() + "\033[0m" + "-->票号为：" + tickets);
            --tickets;
        }
    }
}
方式三：Lock锁
package com.senior.multithread;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 实现线程同步的方式3：Lock锁的形式  JDK5.0新增
 * 1.声明一个Lock：权限 ReentrantLock lock = new ReentrantLock();
 * 2.构建try-finally结构，并将需要同步的代码放到try中
 * 3.在try中同步代码之前调用lock对象的lock()方法
 * 4.finally中调用unlock()方法
 *
 * 讨论：synchronized 和 Lock的区别？
 *      不同之处在于synchronized机制在执行完相应的同步代码之后，会自动的释放同步监视器
 *      Lock的启动和结束同步监视器的作用都需要手动
 * @author eden
 * @create projectTest:2021-05-10-22:17
 */
public class SellTicketsTest3 {
    public static void main(String[] args) {
        SellTickets3 tmp = new SellTickets3();

        Thread windows1 = new Thread(tmp);
        Thread windows2 = new Thread(tmp);
        Thread windows3 = new Thread(tmp);

        windows1.setName("SellTickets--Windows" + windows1.getName());
        windows2.setName("SellTickets--Windows" + windows2.getName());
        windows3.setName("SellTickets--Windows" + windows3.getName());

        windows1.start();
        windows2.start();
        windows3.start();
    }
}

class SellTickets3 implements Runnable {
    private int tickets = 100;
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                //调用lock
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println("\033[0;96m" + Thread.currentThread().getName() + "\033[0m" + "-->票号为：" + tickets);
                    --tickets;
                } else {
                    break;
                }

            } finally {
                lock.unlock();
            }
        }
    }

}

该博客部分图片来源于尚硅谷宋老师教学课件

EdenGabriel
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【多线程】如何保证线程安全
柠檬树
03-15 5万+
一、线程安全等级       之前的博客中已有所提及“线程安全”问题，一般我们常说某某类是线程安全的，某某是非线程安全的。其实线程安全并不是一个“非黑即白”单项选择题。按照“线程安全”的安全程度由强到弱来排序，我们可以将java语言中各种操作共享的数据分为以下5类：不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。          1、不可变       在java语言中，不可变的对象一定...
多线程详解Java三种实现方式+线程安全问题+死锁问题+线程池
qq_48783543的博客
09-26 525
继承Thread类实现多线程 1、run方法（需要重写） （1）：run方法就是线程要执行任务的方法 （2）：启动线程不需要调用run方法，而是调用threa里的start方法来启动任务 （3）：main方法中的叫做主线程，它和其他线程同时执行，其中谁先执行，谁后执行是不一定的（两个线程强占时间分配）看例子： package Day1; public class Demo1 { public static void main(String[] args) { MyThread myT
java 多线程&实例变量共享造成的非线程安全问题与解决方案——9
爱的叹息的专栏
06-04 259
通过在run()方法前加入synchronized关键字，使多个线程在执行 run()方法时，以排队的方式进行处理。一个线程调用run()方法前，先判 断run()方法有没有被上锁，如果run()方法被上锁，则说明其他线程正在 调用run()方法，必须等其他线程对run()方法调用结束后，该线程才可以 执行run()方法，这样也就实现了排队调用run()方法的目的，从而实现按 顺序对count变量减1的效果。synchronized可以对任意对象及方法加锁， 而加锁的这段代码称为“互斥区”或“临界区”。 .
JAVA多线程的三种创建方式
热门推荐
yangyechi的博客
03-03 6万+
一、概述 在JAVA中，用Thread类代表线程，所有线程对象，都必须是Thread类或者Thread类子类的实例。每个线程的任务就是执行一段顺序执行的代码，JAVA使用线程执行体来容纳这段代码。所以，我们创建线程时，主要是根据实际需求，编写放入线程执行体的代码。 二、三种创建方式 2.1第一种，通过继承Thread类创建线程类 通过继承Thread类来创建并启动多线程的步骤...
JAVA多线程处理for循环
m0_60342559的博客
04-06 1万+
public static void main(String[] args) { long start = System.currentTimeMillis(); List list = new ArrayList(); for (int i = 0; i < 1000; i++) { list.add(i); } //定义线程数量为20，可根据服务器配置适当调整大小
Java多线程-对比创建多线程的两种方式
最新发布
01-25
Java多线程编程中，创建线程主要有两种方式：继承`Thread`类和实现`Runnable`接口。这两种方式虽然都能实现多线程，但它们在实际应用中有着不同的特性和适用场景。 首先，我们来看看继承`Thread`类的方式。这种方式...
Java创建线程三种方式的优缺点
08-26
Java创建线程三种方式的优缺点 Java创建线程主要有三种方式：继承Thread类创建线程、实现Runnable接口创建线程和实现Callable和Future创建线程。每种方式都有其优缺点，在实际开发中，选择合适的方式非常重要。 ...
Java多线程-创建多线程的基本方式一：继承Thread类
01-19
Java提供了多种创建多线程的方式，其中最基础的一种是通过继承Thread类来实现。 一、创建和启动线程 1. 概述 Java虚拟机（JVM）支持多线程执行，每个线程都是通过`java.lang.Thread`类的实例来表示的。创建一个...
Java多线程中线程的两种创建方式及比较代码示例
08-28
Java多线程中线程的两种创建方式及比较代码示例 Java多线程中线程的两种创建方式是指在Java编程语言中创建线程的两种方法：通过实现Runnable接口创建线程和通过继承Thread类创建线程。 1. 通过实现Runnable接口...
Java创建线程的两种方式
09-01
Java提供了两种主要的方式来创建线程，分别是继承`Thread`类和实现`Runnable`接口。这两种方式各有优缺点，适用于不同的场景。 ### 继承Thread类 当你选择继承`Thread`类来创建线程，你需要按照以下步骤操作： 1....
ｊａｖａ多线程的创建（继承Thread,实现Runnable接口）
Angela_L的博客
06-05 584
一.什么是线程，进程及创建多线程的方式 什么是进程，进程是正在运行的应用程序，进程是线程的集合。 * 什么是线程，线程是一条执行路径，一个独立的执行单元。 * 什么是多线程 为了提高程序效率 * 创建有哪些方式？ * 1.使用继承Thread类方式 * 2.使用实现runable接口方式 * 3.使用匿名类方式 * 4.cal...
java foreach多线程_正确使用Java事件通知
weixin_35981962的博客
12-26 928
通过实现观察者模式来提供 Java 事件通知(Java event notification)似乎不是件什么难事儿，但这过程中也很容易就掉进一些陷阱。本文介绍了我自己在各种情形下，不小心制造的一些常见错误。Java 事件通知让我们从一个最简单的 Java Bean 开始，它叫StateHolder，里面封装了一个私有的 int 型属性 state 和常见的访问方法：现在假设我们决定要 Java b...
Java并发编程思维导图-究极版
wujialv的博客
09-09 318
思维导图见文末~ Java内存模型（JMM） 线程通信机制 内存共享 Java采用 消息传递 内存模型 重排序 重排序在多线程环境下可能会导致数据不安全 在单线程环境下不能改变程序运行的结果 存在数据依赖关系的不允许重排序 为了程序的性能，处理器、编译器都会对程序进行重排序处理 条件 问题 顺序一致性 一个线程中的所有操作必须按照程序的顺序来执行 所有线程都只能看到一个单一的操作执行顺序，不管程序是否同步 每个操作都必须原子执行且立刻对所有线程可见 多线程环境下的理论参考模型 为程...
Java并发情况下集合的线程安全性
m0_54202121的博客
04-23 650
文章目录ConcurrentModificationException并发修改异常5.1List集合的线程不安全①，使用Vector解决②，使用Collections类的synchronizedList方法③ 使用CopyOnWriteArrayList<>(重点)5.2 HashSet集合的线程不安全5.3HashMap集合的多线程不安全 ConcurrentModificationException并发修改异常 当我们对集合进行迭代(遍历)的时候，同时（并发）对集合进行修改，就会产生并发修改
多线程(二)线程安全
daziyuanazhen的博客
11-09 130
什么是线程安全问题？ 当多个线程同时对一个全局变量做写操作时，可能线程之间会互相影响，导致数据有问题。这种现象就叫做线程安全问题。 解决办法 思路是不要让多个线程对同一个全局变量做写的操作。 为此可以使用同步synchronized或锁(lock)。 原理是线程需要拿到锁才能执行，执行完后会释放锁，然后另一个线程拿到锁，开始执行。多个线程依次执行，即同步，线程之间互不干扰。缺点是多...
实现线程的三种方式以及线程安全
weixin_43946462的博客
05-28 456
  Java中使用Thread代表线程类，所有的线程类都必须是Thread类或者其子类的实例。每个线程的作用就是完成一定的任务，即执行一段程序流。Java中使用线程执行体来表示这段程序流。 Java中线程的实现方式有如下三种： 1.继承Thread类   定义Thread类的子类，并重写Thread类的run()方法，创建子类对象（即线程对象），调用线程对象的start()方法来启动该线程。 package com.example; public class ThreadDemo extends Thre
多线程类变量和方法变量的线程安全
weixin_30533797的博客
11-13 256
今天在网上搜了关于多线程变量的安全问题，这个博文说的比较明白：https://www.cnblogs.com/mengdd/archive/2013/02/16/2913659.html 两种方法： 第一种:将类变量改为方法变量，这样各线程都保存一份自己的拷贝。 第二种:为该方法添加同步特性（synchronized）。 转载于:https://www.cnblogs.com/katsu20...
多线程-解决线程安全问题三种方式（二）
Opal_123的博客
11-22 168
什么是线程安全？ –当多个线程同时共享同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题 举例：模拟火车票售票 方式一：同步方法 public class TestTricks01 { public static void main(String[] args) { TestThread6 thread6 = new TestThrea...
Java多线程有哪几种实现方式? Java中的类如何保证线程安全? 请说明ThreadLocal的用法和适用场景（面试题）
zhanzehong的专栏
03-21 5403
Java多线程有哪几种实现方式? Java中的类如何保证线程安全? 请说明ThreadLocal的用法和适用场景 Java多线程有三种实现方式： (1)继承Thread类，重写run函数 (2)实现Runnable接口，重写run函数 开启线程：Thread t = new Thread(对象) //创建线程对象 t.start() (3)实现Callable接口，重写call函数
Java多线程：对比Thread与Runnable创建方式
"Java编程中，创建多线程有两种主要方式：继承Thread类和实现Runnable接口。这两种方式在实现多线程上有各自的特点和适用场景。下面将详细对比这两种方式，并通过实例进行说明。\n\n一、对比两种方式\n\n（1）对比\n...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值