java多线程的三种创建方式及常用方法和锁使用

最新推荐文章于 2022-03-13 13:03:05 发布
最新推荐文章于 2022-03-13 13:03:05 发布
阅读量319 收藏 1
点赞数 1
分类专栏： java基础知识 文章标签： 多线程 java 多进程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Andrew0219/article/details/119451148
版权
本文详细介绍了Java中创建线程的三种方法：继承Thread类、实现Runnable接口和实现Callable接口。通过实例展示了线程操作同一资源时的安全问题，并讲解了线程的常用方法，如sleep、yield、join和线程状态的获取。此外，还探讨了线程的优先级、守护线程、线程同步机制、死锁和线程通信方法，以及线程池的概念和优势。
摘要由CSDN通过智能技术生成

目录

概念

process 进程 thread线程
程序是静态的，是指令和数据的有序结合
进程是执行程序的一次过程是系统资源分配的单位
线程是CPU执行和调度的单位
.
java默认有两个线程：main和gc垃圾回收
.
java是无法开启线程的，只能调用本地底层的c++
private native void start0();

创建线程的三种方法

方法一：继承thread类，重写run方法，main主函数调用start开启线程

（不建议使用，OOP单继承局限性）

//继承thread类
public class thread extends Thread{

    @Override
    //重写run方法
    public void run() {
        for (int i = 0; i<200; i++){
            System.out.println("这是run线程"+i);
        }
    }

    public static void main(String[] args) {

        thread thread1 = new thread();
        //调用start
        thread1.start();

        for (int i = 0;i<200;i++){
            System.out.println("这是main线程"+i);
        }
    }

}

方法二：实现runnable接口（其实上面的thread也实现了这个接口），重写run方法，main主函数调用start开启线程

（建议使用，避免单继承局限性，灵活使用，方便同一个对象被多个线程使用）

//实现runnable接口
public class runn implements Runnable{
    @Override
    //run方法线程体
    public void run() {
        for (int i = 0; i<200; i++){
            System.out.println("这是run线程"+i);
        }
    }

    public static void main(String[] args) {

        //创建runnable接口实现类对象
        runn runn = new runn();

        //创建线程对象
        Thread thread = new Thread(runn);
        
        //通过线程对象开启线程（代理）
        thread.start();

        //其实上面两句等价于
         new Thread(runn).start();

        for (int i = 0;i<200;i++){
            System.out.println("这是main线程"+i);
        }
    }

}

例子1：多个线程操作同一个资源的情况下，线程是不安全的，数据紊乱。

public class unsafe implements Runnable{

    private int ticket= 10;

    @Override
    public void run() {
            while (true){
                if (ticket<=0){
                    break;
                }
                try {
                    //模拟延迟
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+ "拿到了第" + ticket-- + "张票");
            }
    }

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

        new Thread(unsafe,"小明").start();
        new Thread(unsafe,"小蓝").start();
        new Thread(unsafe,"小黄").start();
    }
}

输出结果为

在这里插入图片描述

例子2：龟兔赛跑

public class rabbit implements Runnable{

    private static String winner;

    @Override
    public void run() {
     for (int i = 0;i<=100;i++){

         //模拟兔子休息
         if (Thread.currentThread().getName().equals("兔子")){
             try {
                 Thread.sleep(1);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }

         //判断比赛是否结束
         boolean flag = gameOver(i);
         if (flag){
             break;
         }

         System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
     }
    }

    private boolean gameOver(int steps){
        //判断是否有胜利者
        if (winner!= null){
            return true;
        }else {
            if (steps>=100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is "+winner);
                return true;
            }
        }

        return false;
    }

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

        new Thread(rabbit,"乌龟").start();
        new Thread(rabbit,"兔子").start();
    }
}

方法三：实现callable接口，需要返回值类型，重写call方法（需要抛出异常）

public class call1 implements Callable {
    @Override
    public Object call() throws Exception {
        for (int x = 0; x < 100; x++) {
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }
        return null;
    }

    public static void main(String[] args) {

        //创建线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(2);

        //提交任务
        pool.submit(new call1());
        pool.submit(new call1());

        //关闭线程池
        pool.shutdown();

    }
}

线程的一些常用方法

线程的停止

建议让线程自己停下来
可以使用一个标志位来停止变量当 flag=false 时，则终止线程
不要使用stop，destory等过时方法或JDK不建议使用的方法

public class testStop implements Runnable{

    private boolean flag=true;

    @Override
    public void run() {
        int i =0;
        while (flag){
            System.out.println("线程在run...."+i);
        }

    }


    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) {

        testStop stop = new testStop ();

        new Thread(stop).start();

        for (int i = 0; i < 1000; i++) {

            System.out.println("main线程在run...."+i);

            if (i == 900){
                stop.stop();
                System.out.println("线程停止了");
            }
        }

    }
}

线程休眠——sleep

可以指定当前线程阻塞的毫秒数，所以可以模拟网络延时，倒计时等
日常可以用sleep放大线程一些问题的发生性
每个对象都有一个锁，sleep不会释放锁

模拟网络延时

别说我偷懒，这里确实用到了sleep

public class TestSleep1 implements Runnable {


        private int ticket = 10;

        @Override
        public void run () {
        while (true) {
            if (ticket <= 0) {
                break;
            }
            try {
                //模拟延迟
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticket-- + "张票");
        }
    }

        public static void main (String[]args){
        com.andrew.thread.unsafe3 unsafe = new com.andrew.thread.unsafe3();

        new Thread(unsafe, "小明").start();
        new Thread(unsafe, "小蓝").start();
        new Thread(unsafe, "小黄").start();
    }
    

}

使用sleep每隔一秒获取系统时间

public class TestSleep2 {

    //模拟倒计时
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Date date = new Date(System.currentTimeMillis());//获取当前时间

        while (true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            date = new Date(System.currentTimeMillis());//更新当前时间
        }

    }

}

线程礼让——yield

线程礼让即A从运行状态，又变成就绪状态，这时候A和B又是同一起跑线继续跑
所以，线程礼让不一定成功

public class TestYield {

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

        new Thread(m,"A").start();
        new Thread(m,"B").start();
    }

}


class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//线程礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

线程强制执行——join

会造成线程阻塞

public class TestJoin implements Runnable{


    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Join插队"+i+"次");
        }
    }

    public static void main(String[] args) throws InterruptedException {

        TestJoin testJoin = new TestJoin();

        Thread thread = new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("main线程运行"+i+"次");
            if (i==50){
                thread.join();
            }
        }

    }
}

观测线程状态——getState()

要注意线程死了之后无法再start()

public class TestLook {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程结束");
        });
        
        //观察状态
        Thread.State state = thread.getState();
        //NEW
        System.out.println(state);

        //观察启动后
        //启动线程
        thread.start();
        state = thread.getState();
        //RUN
        System.out.println(state);

        //只要不终止，就一直输出状态
        while (state != Thread.State.TERMINATED){
            Thread.sleep(100);
            //更新线程状态
            state = thread.getState();
            //输出状态
            System.out.println(state);
        }
    }
}

线程的优先级——setPriority

可以看到优先级高的先执行，但是这其实并不是绝对的，也有少部分不会这样（性能倒置）

public class TestPriority {


    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();


        Thread a1 = new Thread(myPriority);
        Thread a2 = new Thread(myPriority);
        Thread a3 = new Thread(myPriority);
        Thread a4 = new Thread(myPriority);

        a1.start();

        a2.setPriority(3);
        a2.start();

        a3.setPriority(Thread.MAX_PRIORITY);
        a3.start();

        a4.setPriority(7);
        a4.start();

    }
}


class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
    }
}

结果

main--->5
Thread-2--->10
Thread-0--->5
Thread-3--->7
Thread-1--->3

守护线程——Daemon

线程分为用户线程和守护线程
虚拟机会确保用户进程(main…)执行完毕
虚拟机不会确保守护进程(gc…)执行完毕

public class TestDaemon {

    public static void main(String[] args) {
        Daemon daemon = new Daemon();
        Common common = new Common();

        Thread thread = new Thread(daemon);
        //默认是false
        thread.setDaemon(true);
        thread.start();

        new Thread(common).start();
    }

}

//守护线程
class Daemon implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("我是守护线程");
        }
    }
}

//用户线程
class Common implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("我是用户线程---》"+i);
        }
        System.out.println("我结束了");
    }
}

线程同步机制

多个线程访问同一个对象就会产生队列，为了保证线程安全就产生了锁(synchronized)。
锁带来了安全，也带来了不便
1.一个线程持有锁会导致其他需要此锁的线程挂起
2.在多线程竞争下﹐加锁﹐释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
3.如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置,引起性能问题．

列举不安全案例

举例1

每个线程都在自己的工作内存内交互，内存控制不当会造成数据不一致

//不安全买票
public class BuyTicket {

    public static void main(String[] args) {

        Buy buy = new Buy();

        new Thread(buy,"一号").start();
        new Thread(buy,"二号").start();
        new Thread(buy,"三号").start();
    }
}

class Buy implements Runnable{

    private int ticket=10;
    boolean flag=true;

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

    private void judge() throws InterruptedException {
        if (ticket == 0){
            flag = false;
            return;
        }

        Thread.sleep(10);
        System.out.println(Thread.currentThread().getName()+"拿到了第"+ticket--+"张票");
    }

}

举例二

两个线程操作同一个位置，会覆盖，导致线程变少，所以这个输出结果不是一万，而是小于一万

//线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size());
    }
}

锁的常见使用和问题

同步方法

只要在方法上加锁就行

//安全买票
public class BuyTicket {

    public static void main(String[] args) {

        Buy buy = new Buy();

        new Thread(buy,"一号").start();
        new Thread(buy,"二号").start();
        new Thread(buy,"三号").start();
    }
}

class Buy implements Runnable{

    private int ticket=10;
    boolean flag=true;

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

	//在这里加
    private synchronized void judge() throws InterruptedException {
    
    	//判断是否有票
        if (ticket <= 0){
            flag = false;
            return;
        }

        Thread.sleep(10);
        System.out.println(Thread.currentThread().getName()+"拿到了第"+ticket--+"张票");
    }

}

同步块

默认锁的是this
锁的对象就是变化的量，即需要增删改的对象

//线程安全的集合
public class test {
        public static void main(String[] args) {
            List<String> list = new ArrayList<String>();
            for (int i = 0; i < 10000; i++) {
                new Thread(() -> {
                    synchronized (list){
                        list.add(Thread.currentThread().getName());
                    }
                }).start();
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(list.size());
        }

}

死锁

产生死锁的四个条件
互斥条件: 一个资源每次只能被一个进程使用。
请求与保持条件: 一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件: 进程已获得的资源，在末使用完之前，不能强行剥夺。
循环等待条件: 若干进程之间形成一种头尾相接的循环等待资源关系。
大白话就是 我有苹果我想吃梨 你有梨你想吃苹果 但是双手都想让对方先给，自己再给 就卡死了

Lock锁

显式加锁，释放锁
如果同步代码有异常，要将 lock.unlock(); 写入finally语句块
ReentrantLock(可重复锁)实现了Lock

public class test {

        public static void main(String[] args) {

            com.andrew.syn.Buy1 buy = new com.andrew.syn.Buy1();

            new Thread(buy,"一号").start();
            new Thread(buy,"二号").start();
            new Thread(buy,"三号").start();
        }
    }

    class Buy1 implements Runnable{

        private int ticket=10;
        boolean flag=true;
        private final ReentrantLock lock = new ReentrantLock();

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


            }
        }

        private void judge() throws InterruptedException {
            if (ticket == 0){
                flag = false;
                return;
            }

            Thread.sleep(10);
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticket--+"张票");
        }

    }

Lock 锁和synchronized 锁对比

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

线程通信

常用方法wait，notify等

在这里插入图片描述

wait和sleep的区别

1.他们属于不同的类
wait–》object
sleep–》Thread
.
2.wait会释放锁，sleep不会释放锁
.
3.位置不同
wait必须在同步代码块中
sleep可以在任何地方

管程法

利用缓冲区解决

package com.andrew.gaoji;

/**
 * 协作模型:生产者消费者实现方式一:管程法
 * 借助缓冲区
 *
 * @author
 */
//实例：模拟生产馒头
public class TestPC {
    public static void main(String[] args) {
        //缓冲区
        SynContainer container = new SynContainer();
        //生产者
        new Productor(container).start();
        //消费者
        new Consumer(container).start();
    }
}

//生产者
class Productor extends Thread {
    SynContainer container;

    public Productor(SynContainer container) {
        this.container = container;
    }

    public void run() {
        //生产
        for (int i = 0; i < 100; i++) {
            System.out.println("生产-->" + i + "个馒头");
            container.push(new Steamedbun(i));
        }
    }
}

//消费者
class Consumer extends Thread {
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }

    public void run() {
        //消费
        for (int i = 0; i < 100; i++) {
            System.out.println("消费-->" + container.pop().id + "个馒头");
        }
    }
}

//缓冲区
class SynContainer {
    Steamedbun[] buns = new Steamedbun[10]; //存储容器
    int count = 0; //计数器

    //存储 生产
    public synchronized void push(Steamedbun bun) {
        //何时能生产  容器存在空间
        //不能生产 只有等待
        if (count == buns.length) {
            try {
                this.wait(); //线程阻塞  消费者通知生产解除
            } catch (InterruptedException e) {
            }
        }
        //存在空间 可以生产
        buns[count] = bun;
        count++;
        //存在数据了，可以通知消费了
        this.notifyAll();
    }

    //获取 消费
    public synchronized Steamedbun pop() {
        //何时消费 容器中是否存在数据
        //没有数据 只有等待
        if (count == 0) {
            try {
                this.wait(); //线程阻塞  生产者通知消费解除
            } catch (InterruptedException e) {
            }
        }
        //存在数据可以消费
        count--;
        Steamedbun bun = buns[count];
        this.notifyAll(); //存在空间了，可以唤醒对方生产了
        return bun;
    }
}

//馒头
class Steamedbun {
    int id;

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

信号灯法

用标志位解决
需要注意的是 wait 最好用 while 来判断而不是if，我这里其实有点不规范

//信号灯法
public class TestPC2 {

    public static void main(String[] args) {

        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }


}
//生产者--演员
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2==0){
                this.tv.play("天天向上");
            }else {
                this.tv.play("跑男");
            }
        }
    }
}

//消费者--观众
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//产品--》节目
class TV{
    //演员表演，观众等待  T
    //观众观看，演员等待  F
    //表演节目
    String voice;
    boolean flag = true;

    //表演
    public synchronized void play(String voice){
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了:"+voice);
        //通知观众观看
        //通知唤醒
        this.notifyAll();
        this.voice = voice;
        this.flag = !this.flag;
    }

    //观看
    public synchronized void watch(){

        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("观众观看了:"+voice);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }

}

线程池

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

好处:
提高响应速度（减少了创建新线程的时间)
降低资源消耗（重复利用线程池中线程，不需要每次都创建)
便于线程管理(……)
1.corePoolSize:核心池的大小
2.maximumPoolSize:最大线程数
3.keepAliveTime:线程没有任务时最多保持多长时间后会终止

public class TestPool {

    public static void main(String[] args) {

        //创建服务，创建线程池
        //newFixedThreadPool参数为线程池大小
        ExecutorService service1 = Executors.newFixedThreadPool(10);

        service1.execute(new MyThread());
        service1.execute(new MyThread());
        service1.execute(new MyThread());
        service1.execute(new MyThread());

        //关闭连接
        service1.shutdown();
    }

}

class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
Andrew0219
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JAVA如何在线程中加锁（四种方法）
weixin_43907440的博客
04-22 2万+
JAVA多线程锁 线程的生命周期 ​ 总共六种状态，可归结为五种，线程的最终是死亡，阻塞不是最终状态，只是一个临时状态。只有调用了start方法，线程才进入就绪阶段。 //新生 ​ NEW, //运行​ RUNNABLE, //阻塞​ BLOCKED, //等待，死死地等​ WAITING, //超时等待​ TIMED_WAITING, //终止​ ...
Java多线程-Thread类的常用结构及线程优先级
最新发布
01-27
Java多线程编程是开发高并发应用的基础，其中Thread类是实现多线程的核心类。本文将详细解析Thread类的常用结构以及线程优先级。 一、Thread类的常用结构 1. 线程中的构造器 - `Thread()`：创建一个没有指定名称...
JAVA三种线程锁
小冷在努力~
01-07 3154
内置锁：synchriozed，关键字，同步代码块，object.wait和object.notify/notifyall 显示锁：Lock，JUC包下的类，同步代码块，condition.await和condition.signal/signalall 原子类：Atomic，JUC包下的类，原理CAS，注意ABA问题 Lock接口方法有lock、unlock、trylock、newCondition try { lock.lock(); System.out.println( lock....
【JUC】Java多线程中synchronized加锁的三种方式
fearless的博客
06-11 1361
1.对象锁（同步块）——锁某一个对象 对象锁：顾名思义给对象上锁 当A线程访问一个object的时候，首先会获取该对象的对象锁，然后访问锁定的代码，而B线程访问一个对象object多顶的代码区时，因为线程A之前获取到对象object的对象锁，因此线程B访问同步代码区的时候会被阻塞，直到线程A执行完同步代码块，然后释放对象锁，B线程获取对象object的对象锁，才能进行访问同步代码块 用法：synchronized (this){ //—-同步代码块——— } this表示当前访问同步代码区的对象 特
java多线程 多线程之间共享数据（不安全），run方法上加锁可解决
weixin_43960044的博客
10-17 718
学习目标： java多线程学习 学习内容： 提示：这里可以添加要学的内容 例如： 1、 搭建 Java 开发环境 2、 掌握 Java 基本语法 3、 掌握条件语句 4、 掌握循环语句 学习时间： 学习产出： 实现多线程编程方式有两种：继承Thread类、实现Runable接口 区别：java是单继承的，继承Thread类后就不能再次被继承了，可以通过实现Runable之后再继承来达到多继承的目的。 联系：Thread 实现 Runable 接口 线程之间共享数据（新建使用同一个类，有可能造成线程不安全
java锁实现方式有哪些_5.Java中的锁的使用和实现介绍
weixin_34008968的博客
02-17 656
Java并发编程的艺术笔记目录Lock接口队列同步器重入锁读写锁LockSupport工具Condition接口小结Lock接口在Java SE 5之后，并发包中新增了Lock接口(以及相关实现类)用来实现锁功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需要 显式 地获取和释放锁。虽然它缺少了(通过synchronized块或者方法所提供的)隐式获取释放锁的便捷性，但是...
Java创建线程三种方式的优缺点
08-26
实现Runnable接口创建线程是Java中另一种常用的线程创建方式。这种方式下，需要创建一个实现Runnable接口的类，并重写run方法。例如： ```java public class Thread2 implements Runnable { @Override public ...
Java多线程三种主要实现方式解析
08-18
Java多线程三种主要实现方式解析 Java多线程三种主要实现方式解析是Java编程语言中最重要的概念之一。在 Java 中，实现多线程有多种方式，本文将详细介绍 Java 中的三种主要实现方式：继承Thread类、实现Runnable...
Java 创建线程的3种方法及各自的优点
08-18
Java 创建线程是多线程编程中的基础操作，它允许程序同时执行多个任务，提高系统的并发性和效率。本文将详细探讨Java中创建线程的三种方法及其各自的优势。 1. **继承 Thread 类**： 当你需要自定义线程的行为时，...
Java 多线程的创建方式
12-22
在Java中，创建线程主要有三种方式：继承Thread类、实现Runnable接口以及使用ExecutorService和Future，但在这里，我们主要讨论前两种常用的方式。 **第一种方式：继承Thread类** 在Java中，`Thread`类是所有线程...
线程创建的三种方式及锁
qq_48292607的博客
03-13 846
线程和进程是什么？ 线程是操作系统能够进行运算调度的最小单位，他被包含在进程之中。 进程是计算机系统进行资源分配和调度的基本单位，一个进程中可以有多个线程。 线程的状态分为几个过程 1.新建(NEW)：新创建了一个线程对象。 2.可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。 3.运行(RUNNING)：可运行状态(runnable)的线程获得了cpu
java自定义线程锁
qq_29496169的博客
04-20 281
先了解一下sychronized关键字的缺陷 1.无法控制阻塞时长 2.线程进入阻塞状态后是无法被中断的 分析：线程在进入同步块后执行代码的时间无法预计，且无法被中断，存在一定的安全隐患 解决：可以使用自定义的锁来解决这个问题 第一步：建立自定义锁的接口 import org.omg.CORBA.TIMEOUT; import java.util.List; import jav...
Java—线程锁
zhaoqingquanajax的博客
01-08 668
Java多线程的锁都是基于对象的。 Java类只有一个Class对象（可以有多个实例对象，多个实例共享这个Class对象），而Class对象也是特殊的Java对象。所以我们常说的类锁，其实就是Class对象的锁。 synchronized ：同步。java线程锁关键字。 通过synchronized关键字加锁主要有三种形式： public class Sync { public final static Object lock = new Object(); //锁为当前对象 p
Java细粒度锁实现的3种方式
X-man
02-03 4204
1. 分段锁 借鉴concurrentHashMap的分段思想，先生成一定数量的锁，具体使用的时候再根据key来返回对应的lock。这是几个实现里最简单，性能最高，也是最终被采用的锁策略，代码如下： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1
java锁的实现方式_Java 集群锁如何实现呢？
weixin_35721739的博客
02-16 561
针对分布式锁的实现，目前比较常用的有以下几种方案：基于数据库实现分布式锁 基于缓存(redis，memcached，tair)实现分布式锁 基于Zookeeper实现分布式锁基于数据库表要实现分布式锁，最简单的方式可能就是直接创建一张锁表，然后通过操作该表中的数据来实现了。当我们要锁住某个方法或资源时，我们就在该表中增加一条记录，想要释放锁的时候就删除这条记录。基于缓存实现分布式锁相比较于基于数据...
java线程创建3种方式_Java创建线程的三种方式及其对比
weixin_32101377的博客
02-17 96
Java中创建线程主要有三种方式：一、继承Thread类创建线程类(1)定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。(2)创建Thread子类的实例，即创建了线程对象。(3)调用线程对象的start()方法来启动该线程。package com.thread;public class FirstThreadTest ...
Java线程-线程池-锁（lock）
brimen的博客
03-12 5292
在Java5当中，专门提供了锁对象，利用锁可以方便的实现对资源的封锁，用来控制对竞争资源并发访问控制，这些内容主要集中在java.util.concurrent.locks包下面，里面有三个重要的接口Condition、Lock、ReadWriteLock。 Condition将Object监视器方法（wait、notify和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意Lo...
Java 多线程 并发 锁 Java线程面试题
lovezhaohaimig的博客
05-12 6478
1) 什么是线程？线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支持，它也是一个很好的卖点。2) 线程和进程有什么区别？线程是进程的子集，一个进程可以有很多线程，每条线...
【Java多线程】wait()，sleep()，notify()和notifyAll()方法详解
少侠露飞的学习笔记
07-11 3314
  sleep()是线程类(Thread)的方法，导致此线程暂停执行指定的时间，到时后会自动恢复，调用sleep()不会释放对象锁。 sleep()方法是正在执行的线程主动让出CPU。wait()是Object类的方法，对此对象调用wait()方法导致本线程放弃对象锁，进入对象的等待锁定池，只有当此对象调用notify()方法（或notifyAll()）后，本线程才进入对象锁定池准备获得对象锁进入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Andrew0219

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值