java-线程

最新推荐文章于 2024-05-05 13:57:09 发布
最新推荐文章于 2024-05-05 13:57:09 发布
阅读量65 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/damowangsx/article/details/119946209
版权

学习线程所作笔记

线程创建

1.继承Thread类（不建议使用因为java是单继承）
2.时间Runnable接口（推荐使用）

多线程案例（龟兔赛跑）

public class Race implements Runnable {
    private static String winner;
    @Override
    public void run() {

        for (int i = 0; i <= 100; i++) {
            if(Thread.currentThread().getName().equals("兔子")&&i%10==0){
                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;
        }
        if(steps==100){
            winner=Thread.currentThread().getName();
            System.out.println("winner is "+winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Race race=new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

在这里插入图片描述

线程状态（六种线程状态，获取线程状态的方法）

在这里插入图片描述
在这里插入图片描述
NEW
尚未启动的线程的线程状态。
RUNNABLE
一个可运行的线程的线程状态。
TIMED_WAITING
具有指定等待时间的等待线程的线程状态。
TERMINATED
终止线程的线程状态。
BLOCKED
被阻塞等待监视器锁定的线程处于此状态
WAITING
正在等待另一个线程执行特定动作的线程处于此状态

public class StateThread {
    public static void main(String[] args) {
        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();
        System.out.println(state);

        thread.start();
        state=thread.getState();
        System.out.println(state);
        
        while(state!=Thread.State.TERMINATED){
            try {
                Thread.sleep(100);
                state=thread.getState();
                System.out.println(state);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

1.void setPriority(int newPriority) 更改此线程的优先级。
2.static void sleep(long millis) 当前正在执行的线程休眠（暂停执行）为指定的毫秒数。
3.void join() 等待该线程终止。
4.static void yield() 暂停当前正在执行的线程对象，并执行其他线程。
5.boolean isAlive() 测试这个线程是否处于活动状态。

线程的优先级（setPriority方法使用）

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了。

public class PriorityThread {
    public static void main(String[] args) {
        //主线程优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        MyPriority myPriority=new MyPriority();
        Thread t1=new Thread(myPriority);
        Thread t2=new Thread(myPriority);
        Thread t3=new Thread(myPriority);
        Thread t4=new Thread(myPriority);
        Thread t5=new Thread(myPriority);
        Thread t6=new Thread(myPriority);

        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

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

        t5.setPriority(7);
        t5.start();

        t6.setPriority(8);
        t6.start();
    }
}
class MyPriority implements Runnable{

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

停止线程（自定义）

public class StopThread implements Runnable {
    private  boolean flag=true;
    @Override
    public void run() {
        int i=0;
        while(flag){
            System.out.println("run ... thread"+i++);
        }
    }
    //公开方法停止线程
    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) {
        StopThread stopThread=new StopThread();
        new Thread(stopThread).start();
        for(int i=0;i<1000;i++){
            System.out.println("main" + i);
            if(i==900){
                stopThread.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

线程休眠（sleep方法使用）

import java.text.SimpleDateFormat;
import java.util.Date;

public class SleepThread {
    public static void main(String[] args) {

        tenDown();
        /*Date startTime=new Date(System.currentTimeMillis());
        while(true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime=new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }*/
    }
    //倒计时
    public static void tenDown(){
        int num=10;
        while(true){
            try {
                Thread.sleep(1000);
                System.out.println(num--);
                if(num<=0){
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程的礼让（yield方法的使用）

public class YieldThread {
    public static void main(String[] args) {
        MyYield myYield =new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"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 JoinThread implements Runnable {

    public static void main(String[] args) {
        JoinThread joinThread=new JoinThread();
        Thread thread = new Thread(joinThread);
        thread.start();
        for (int i = 0; i < 500; i++) {
            if(i==200){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main"+i);
        }
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程vip来了"+i);
        }
    }
}

守护(daemon)线程

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕

public class DaemonThread {
    public static void main(String[] args) {
            God god=new God();
            You you=new You();

            Thread thread=new Thread(god);
            thread.setDaemon(true);//设置为保护线程
            thread.start();
            new Thread(you).start();
    }
}
class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝守护你");
        }
    }
}
class You implements  Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生都开心的或者");
        }
        System.out.println("你死了");
    }
}

线程不安全案例

售票问题
public class UnsafeBuyTicket  {
    public static void main(String[] args) {
        BuyTicket station=new BuyTicket();
        new Thread(station,"张一").start();
        new Thread(station,"张二").start();
        new Thread(station,"张三").start();
    }
}
class BuyTicket implements Runnable{

    //票
    private int ticketNums=10;
    boolean flag=true;
    @Override
    public void run() {
        while(flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    private void buy() throws InterruptedException {
        if(ticketNums<=0){
            flag=false;
            return ;
        }
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

在这里插入图片描述

取钱问题
//不安全取钱
public class UnsafeBank {
    public static void main(String[] args) {
        Account account=new Account(100,"结婚基金");
        Drawing you=new Drawing(account,50,"你");
        Drawing girlFriend=new Drawing(account,100,"girlFriend");
        you.start();
        girlFriend.start();
    }
}
//账户
class Account{
    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//银行
class Drawing extends Thread{
    //账户
    Account account;
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int mowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    @Override
    public void run() {

        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额=余额-你取得钱
        account.money=account.money-drawingMoney;
        //你手里的钱
        mowMoney=mowMoney+drawingMoney;
        System.out.println(account.name+"余额为："+account.money);
        System.out.println(Thread.currentThread().getName()+"手里的钱"+mowMoney);
    }
}

在这里插入图片描述

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

在这里插入图片描述

同步方法(synchronized)

synchronized默认锁是this

买票
public class UnsafeBuyTicket  {
    public static void main(String[] args) {
        BuyTicket station=new BuyTicket();
        new Thread(station,"张一").start();
        new Thread(station,"张二").start();
        new Thread(station,"张三").start();
    }
}
class BuyTicket implements Runnable{
    //票
    private int ticketNums=10;
    boolean flag=true;
    @Override
    public void run() {
        while(flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    private synchronized void buy() throws InterruptedException {
        if(ticketNums<=0){
            flag=false;
            return ;
        }
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

在这里插入图片描述

银行（synchroniezd同步块）
public class UnsafeBank {
    public static void main(String[] args) {
        Account account=new Account(100,"结婚基金");
        Drawing you=new Drawing(account,50,"你");
        Drawing girlFriend=new Drawing(account,100,"girlFriend");
        you.start();
        girlFriend.start();
    }
}
//账户
class Account{
    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//银行
class Drawing extends Thread{
    //账户
    Account account;
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int mowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }
    //取钱
    @Override
    public void run() {
        synchronized (account){
            if(account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额=余额-你取得钱
            account.money=account.money-drawingMoney;
            //你手里的钱
            mowMoney=mowMoney+drawingMoney;
            System.out.println(account.name+"余额为："+account.money);
            System.out.println(Thread.currentThread().getName()+"手里的钱"+mowMoney);
        }
    }
}
集合
package ThreadSafetyIssues;

import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        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());
    }
}

在这里插入图片描述

安全集合（CopyOnWriteArrayList）

import java.util.concurrent.CopyOnWriteArrayList;

public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

在这里插入图片描述

死锁情况

线程死锁是指两个或两个以上的线程互相持有对方所需要的资源，由于synchronized的特性，一个线程持有一个资源，或者说获得一个锁，在该线程释放这个锁之前，其它线程是获取不到这个锁的，而且会一直死等下去，因此这便造成了死锁。

package deadlock;

public class DeadLock {
    public static void main(String[] args) {
        Makeup gril1=new Makeup(0,"gril1");
        Makeup gril2=new Makeup(1,"gril2");
        gril1.start();
        gril2.start();
    }
}
class Lipstick{

}
class Mirror{

}
class Makeup extends Thread{

    static Lipstick lipstick=new Lipstick();
    static Mirror mirror=new Mirror();

    int choice;//选择

    String girlName;//使用化妆品的人

    public Makeup(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }

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

    }

    private  void makeup() throws InterruptedException {
        if(choice==0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){//一秒钟后获得镜子的锁
                    System.out.println(this.girlName+"获得镜子的锁");
                }
            }
        }else{
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(1000);
                synchronized (lipstick){//一秒钟后获得镜子的锁
                    System.out.println(this.girlName+"获得口红的锁");
                }
            }
        }
    }
}

在这里插入图片描述

Lock锁

Lock是显示锁（手动开启和关闭锁）

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock=new TestLock2();
        new Thread(testLock).start();
        new Thread(testLock).start();
        new Thread(testLock).start();
    }
}

class TestLock2 implements Runnable{
    int ticketNums=10;
    //定义lock锁
    private final ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while(true){
            try{
                //加锁
                lock.lock();
                if(ticketNums>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else{
                    break;
                }
            }finally {
                lock.unlock();
            }
        }
    }
}

线程通信

1.wait();表示线程一直等待，直到其他线程通知，与sleep不同会释放锁
2.wait();指定等待的毫秒数
3.notify()l唤醒一个处于等待的线程
4.notifyAll();唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

生产者消费则问题（管程法）
package ProducerConsumerModel;

//生产者，消费者，产品，缓冲区
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;
    }
    //生产

    @Override
    public void run() {
        for (int i = 0 ; i <100 ; i++) {
            System.out.println("生产了"+i+"鸡");
            container.push(new Chicken(i));
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container;

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

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了--->"+container.pop().id+"只鸡");
        }
    }
}
//产品
class Chicken{
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer{
    //需要一个容器大小
    Chicken[] chickens=new Chicken[10];
    //容器计数器
    int count=0;
    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，等待消费者消费
        if(chickens.length==count){
            //通知消费者消费，生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满就将产品丢尽缓冲区
        chickens[count]=chicken;
        count++;
        //可以通知消费者消费
        this.notifyAll();

    }
    //消费者消费产品
    public  synchronized Chicken pop(){
        if(count==0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken=chickens[count];

        //吃完了，通知生产者生产
        this.notifyAll();
        return chicken;
    }
}
生产者消费则问题（信号灯法）
package ProducerConsumerModel;

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++){
            this.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;
    }
}

使用线程池

package ThreadPool;

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

public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        //参数为线程池大小
        ExecutorService service= Executors.newFixedThreadPool(10);
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //关闭连接
        service.shutdown();

    }
}

class MyThread implements Runnable{
    @Override
    public void run() {

            System.out.println(Thread.currentThread().getName());

    }
}
Oldsongx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java-线程.pdf
10-02
Java-线程.pdf
java---线程安全详解
m0_58196614的博客
08-10 4294
线程安全是指某个方法或某段代码，在多线程中能够正确的执行，不会出现数据不一致或数据污染的情况，我们把这样的程序称之为线程安全的，反之则为非线程安全的。
12jmu-Java-07多线程-Thread
ihopeyousuccess的博客
11-30 1787
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
JAVA线程
互联网底层民工的博客
06-26 7282
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。
java--守护线程
卿本佳人的博客
02-20 3959
守护线程 gc线程 （线程不定时回收垃圾）属于守护线程 当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程 和主线程一起销毁 setDaemon(true)必须在调用线程的start（）方法之前设置，否则会抛出IllegalThreadStateException异常。 在守护线程中产生的新线程也是守护线程。 什么情况下会需要守护线程呢？ 一般情况下是，当我们希望创建一个线程来执行一些辅助的工作，但是又不希望这个线程阻碍 JVM 的关闭，在这种情况下，我们就需要使用守护线程了。
013jmu-Java-07多线程-PrintTask
ihopeyousuccess的博客
11-30 4420
编写PrintTask类实现Runnable接口。 功能：输出从0到n-1的整数(n在创建PrintTask对象的时候指定)。并在最后使用System.out.println(Thread.currentThread().getName());输出标识信息。 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即PrintTask类的代码/ public class Main { public static void main(String[] args) { Scann
java -xss_Java线程与Xss
weixin_31302909的博客
02-12 3647
jvm系列Xss与线程个数Xss越大，每个线程的大小就越大，占用的内存越多，能容纳的线程就越少；Xss越小，则递归的深度越小，容易出现栈溢出 java.lang.StackOverflowError。减少局部变量的声明，可以节省栈帧大小，增加调用深度。/*** -Xss128K deep of calling = 675* -Xss256K deep of calling = 1686*...
6-6 jmu-Java-07多线程-同步访问 (10 分)
m0_54524462的博客
12-02 3053
6-6 jmu-Java-07多线程-同步访问 (10 分) 现已有Account类，拥有 属性: private int balance 方法: 相应的getter方法。 要求为该类编写： void deposit(int money) //存钱，在余额的基础上加上money void withdraw(int money) //取钱，在余额的基础上减去money 注意： 取钱时如果balance<0的时候，会抛出异常。在多线程情况下，如只有一个存钱的线程，但是有多个取钱的线程，很可能会抛出异常。
6-1 jmu-Java-07多线程-Thread (20分)
sddfnsff的博客
05-26 5814
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
 jmu-Java-07多线程-同步访问 (10分)
嗯呢嗯呢的博客
06-06 6019
jmu-Java-07多线程-同步访问(10分) 现已有Account类，拥有属性:private int balance方法: 相应的getter方法。 要求为该类编写：void deposit(int money)//存钱，在余额的基础上加上moneyvoid withdraw(int money)//取钱，在余额的基础上减去money 注意： 取钱时如果balance<0的时候，会抛出异常。在多线程情况下，如只有一个存钱的线程，但是有多个取钱的线程，很可能会抛出异常。 需要编写完...
jmu-Java-07多线程-互斥访问
qq_hua_xia的博客
10-27 1835
题目详情： 6-2 jmu-Java-07多线程-互斥访问 (10 分) 定义Account类属性：private int balance方法： getter方法void deposit(int money)//存钱，在余额的基础上加上moneyvoid withdraw(int money)//取钱，在余额的基础上减去money 注意：可能有多个线程通过deposit或withdraw方法同时存取Account对象的balance属性。 裁判测试程序： import java.util.S..
Java-线程PPT课件.ppt
07-30
Java-线程PPT课件.ppt
Java面试-线程.doc
05-06
Java面试-线程.doc
JAVA-多线程 所有文件
01-09
JAVA-多线程 所有文件
java-多线程 test
06-11
java-多线程 test
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1044
介绍了Java泛型中的重要知识点——通配泛型及其应用。
springboot 获取maven打包时间
I do more ，you do less
04-30 472
【代码】springboot 获取maven打包时间。
leetcode16-3Sum Closest
我的程序人生
04-29 440
这道题目和那道3Num的题目很类似，解题思路也是类似的，我们先对数组排序，然后固定一个元素，通过双指针遍历剩下的元素，用一个哨兵记录三个元素的和与target的diff，分别处理三个元素的和小于target，大于target，等于target这三种情况即可。请你从 nums 中选出三个整数，使它们的和与 target 最接近。解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2)。输入：nums = [-1,2,1,-4], target = 1。假定每组输入只存在恰好一个解。
Java---类和方法的再学习
最新发布
m0_74012211的博客
05-05 1046
Java类与对象
java object monitor_Java-线程状态、ObjectMonitor
06-02
Java中的Object Monitor是用于实现线程同步和互斥的机制。每个Java对象都与一个Object Monitor相关联，这个Monitor是用来控制并发访问该对象的线程的。 Object Monitor有两种状态：空闲状态和占用状态。当一个线程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值