Java-10.2

最新推荐文章于 2022-09-11 21:06:25 发布
最新推荐文章于 2022-09-11 21:06:25 发布
阅读量198 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Desperate_gh/article/details/108899735
版权

CyclicBarrier
用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。
和 CountdownLatch 相似，都是通过维护计数器来实现的。线程执行 await() 方法之后计数器会减 1，并进行等待，直到计数器为 0，所有调用 await() 方法而在等待的线程才能继续执行。
CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset() 方法可以循环使用，所以它才叫做循环屏障。
CyclicBarrier 有两个构造函数，其中 parties 指示计数器的初始值，barrierAction 在所有线程都到达屏障的时候会执行一次。

public CyclicBarrier(int parties, Runnable barrierAction) {
    if (parties <= 0) throw new IllegalArgumentException();
    this.parties = parties;
    this.count = parties;
    this.barrierCommand = barrierAction;
}

public CyclicBarrier(int parties) {
    this(parties, null);
}

在这里插入图片描述

public class CyclicBarrierExample {

    public static void main(String[] args) {
        final int totalThread = 10;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < totalThread; i++) {
            executorService.execute(() -> {
                System.out.print("before..");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.print("after..");
            });
        }
        executorService.shutdown();
    }
}

before..before..before..before..before..before..before..before..before..before..after..after..after..after..after..after..after..after..after..after..

Semaphore
Semaphore 类似于操作系统中的信号量，可以控制对互斥资源的访问线程数。
以下代码模拟了对某个服务的并发请求，每次只能有 3 个客户端同时访问，请求总数为 10。

public class SemaphoreExample {

    public static void main(String[] args) {
        final int clientCount = 3;
        final int totalRequestCount = 10;
        Semaphore semaphore = new Semaphore(clientCount);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < totalRequestCount; i++) {
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    System.out.print(semaphore.availablePermits() + " ");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            });
        }
        executorService.shutdown();
    }
}

1 0 1 0 1 2 2 2 2 1

结果不唯一!

补充：

  1. Semaphore是什么，能做什么？
    Semaphore 是 synchronized 的加强版，作用是控制线程的并发数量。就这一点而言，单纯的synchronized 关键字是实现不了的。
    直接看例子吧，这个例子包含3个类，一个是线程类，一个是 Semaphore 关键代码类，一个类是主main方法类：
    线程类MyThread：
package test_semaphore_1;

public class MyThread extends Thread{

	private SemaphoreService service;

    public MyThread(String name, SemaphoreService service) {
        super();
        this.setName(name);
        this.service = service;
    }

    @Override
    public void run() {
        this.service.doSomething();
    }
}

SemaPhore关键代码类：

package test_semaphore_1;

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

public class SemaphoreService {

	private static SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    private Semaphore semaphore = new Semaphore(1);// 同步关键类，构造方法传入的数字是多少，则同一个时刻，只运行多少个进程同时运行制定代码

    public void doSomething() {
        try {
            /**
             * 在 semaphore.acquire() 和 semaphore.release()之间的代码，同一时刻只允许制定个数的线程进入，
             * 因为semaphore的构造方法是1，则同一时刻只允许一个线程进入，其他线程只能等待。
             * */
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName() + ":doSomething start-" + getFormatTimeStr());
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + ":doSomething end-" + getFormatTimeStr());
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static String getFormatTimeStr() {
        return sf.format(new Date());
    }
}

main方法测试类：

package test_semaphore_1;

public class SemaphoreTest {

	public static void main(String args[]) {
        SemaphoreService service = new SemaphoreService();
        for (int i = 0; i < 10; i++) {
            MyThread t = new MyThread("thread" + (i + 1), service);
            t.start();// 这里使用 t.run() 也可以运行，但是不是并发执行了 
        }
    }
}

结果：

thread1:doSomething start-2020-10-02 10:27:05.506
thread1:doSomething end-2020-10-02 10:27:07.507
thread2:doSomething start-2020-10-02 10:27:07.507
thread2:doSomething end-2020-10-02 10:27:09.508
thread3:doSomething start-2020-10-02 10:27:09.508
thread3:doSomething end-2020-10-02 10:27:11.509
thread4:doSomething start-2020-10-02 10:27:11.509
thread4:doSomething end-2020-10-02 10:27:13.509
thread5:doSomething start-2020-10-02 10:27:13.509
thread5:doSomething end-2020-10-02 10:27:15.509
thread6:doSomething start-2020-10-02 10:27:15.509
thread6:doSomething end-2020-10-02 10:27:17.510
thread7:doSomething start-2020-10-02 10:27:17.510
thread7:doSomething end-2020-10-02 10:27:19.510
thread8:doSomething start-2020-10-02 10:27:19.510
thread8:doSomething end-2020-10-02 10:27:21.511
thread9:doSomething start-2020-10-02 10:27:21.511
thread9:doSomething end-2020-10-02 10:27:23.512
thread10:doSomething start-2020-10-02 10:27:23.512
thread10:doSomething end-2020-10-02 10:27:25.513

实践证明，确实是同一个时刻只有一个线程能访问，那如果把 Semaphore 的构造方法入参改成 2 呢，修改 SemaphoreService.java 文件：

package test_semaphore_1;

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

public class SemaphoreService {

	private static SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    private Semaphore semaphore = new Semaphore(2);// 同步关键类，构造方法传入的数字是多少，则同一个时刻，只运行多少个进程同时运行制定代码

    public void doSomething() {
        try {
            /**
             * 在 semaphore.acquire() 和 semaphore.release()之间的代码，同一时刻只允许制定个数的线程进入，
             * 因为semaphore的构造方法是1，则同一时刻只允许一个线程进入，其他线程只能等待。
             * */
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName() + ":doSomething start-" + getFormatTimeStr());
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + ":doSomething end-" + getFormatTimeStr());
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static String getFormatTimeStr() {
        return sf.format(new Date());
    }
}

结果：

thread2:doSomething start-2020-10-02 10:34:13.796
thread1:doSomething start-2020-10-02 10:34:13.796
thread1:doSomething end-2020-10-02 10:34:15.797
thread2:doSomething end-2020-10-02 10:34:15.797
thread3:doSomething start-2020-10-02 10:34:15.797
thread4:doSomething start-2020-10-02 10:34:15.797
thread3:doSomething end-2020-10-02 10:34:17.798
thread4:doSomething end-2020-10-02 10:34:17.798
thread5:doSomething start-2020-10-02 10:34:17.798
thread6:doSomething start-2020-10-02 10:34:17.798
thread6:doSomething end-2020-10-02 10:34:19.798
thread5:doSomething end-2020-10-02 10:34:19.798
thread7:doSomething start-2020-10-02 10:34:19.798
thread8:doSomething start-2020-10-02 10:34:19.798
thread7:doSomething end-2020-10-02 10:34:21.798
thread8:doSomething end-2020-10-02 10:34:21.798
thread9:doSomething start-2020-10-02 10:34:21.798
thread10:doSomething start-2020-10-02 10:34:21.798
thread9:doSomething end-2020-10-02 10:34:23.799
thread10:doSomething end-2020-10-02 10:34:23.799
  1. 方法 acquire( int permits ) 参数作用，及动态添加 permits 许可数量　
    acquire( int permits ) 中的参数是什么意思呢？可以这么理解， new Semaphore(6) 表示初始化了 6个通路， semaphore.acquire(2) 表示每次线程进入将会占用2个通路，semaphore.release(2) 运行时表示归还2个通路。没有通路，则线程就无法进入代码块。
    而上面的代码中，semaphore.acquire() + semaphore.release() 在运行的时候，其实和 semaphore.acquire(1) + semaphore.release(1) 效果是一样的。　　
    上代码：
    线程类MyThread：
package test_semaphore_2;

public class MyThread extends Thread{

	private SemaphoreService2 service;

    public MyThread(String name, SemaphoreService2 service) {
        super();
        this.setName(name);
        this.service = service;
    }

    @Override
    public void run() {
        this.service.doSomething();
    }
}

SemaPhore关键代码类：

package test_semaphore_2;

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

public class SemaphoreService2 {

	private static SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    private Semaphore semaphore = new Semaphore(6);//6表示有6个通路
    
    public void doSomething() {
        try {
            semaphore.acquire(2); // 2 表示进入此代码，就会消耗2个通路，2个通路从6个中扣除
            System.out.println(Thread.currentThread().getName() + ":doSomething start-" + getFormatTimeStr());
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + ":doSomething end-" + getFormatTimeStr());
            semaphore.release(2); // 释放占用的 2 个通路
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public int availablePermits() {    // 查看可用通路数
        return semaphore.availablePermits();
    }
    
    public static String getFormatTimeStr() {
        return sf.format(new Date());
    }
}

main方法测试类：

package test_semaphore_2;

public class SemaphoreTest2 {

	public static void main(String args[]) {
        SemaphoreService2 service = new SemaphoreService2(); // 使用总 6 通路，每个线程占用2通路
        for (int i = 0; i < 10; i++) {
            MyThread t = new MyThread("thread" + (i + 1), service);
            t.start();// 这里使用 t.run() 也可以运行，但是不是并发执行了 
            System.out.println("可用通路数：" + service.availablePermits());
        }
    }
}

结果：

可用通路数：6
可用通路数：4
可用通路数：2
可用通路数：0
可用通路数：0
thread1:doSomething start-2020-10-02 10:46:15.142
thread3:doSomething start-2020-10-02 10:46:15.142
thread2:doSomething start-2020-10-02 10:46:15.142
可用通路数：0
可用通路数：0
可用通路数：0
可用通路数：0
可用通路数：0
thread1:doSomething end-2020-10-02 10:46:17.142
thread3:doSomething end-2020-10-02 10:46:17.142
thread2:doSomething end-2020-10-02 10:46:17.142
thread5:doSomething start-2020-10-02 10:46:17.142
thread4:doSomething start-2020-10-02 10:46:17.142
thread6:doSomething start-2020-10-02 10:46:17.142
thread6:doSomething end-2020-10-02 10:46:19.142
thread5:doSomething end-2020-10-02 10:46:19.142
thread4:doSomething end-2020-10-02 10:46:19.142
thread8:doSomething start-2020-10-02 10:46:19.142
thread7:doSomething start-2020-10-02 10:46:19.142
thread9:doSomething start-2020-10-02 10:46:19.142
thread8:doSomething end-2020-10-02 10:46:21.143
thread7:doSomething end-2020-10-02 10:46:21.143
thread9:doSomething end-2020-10-02 10:46:21.143
thread10:doSomething start-2020-10-02 10:46:21.143
thread10:doSomething end-2020-10-02 10:46:23.144

结果不唯一！

如果 acquire 的数量大于 release 的数量，则 通路迟早会被使用完，如果线程比较多，得不到后续运行，出现线程堆积内存，最终java进程崩掉；如果 acquire 的数量小于 release 的数量，就会出现并发执行的线程越来越多（换句话说，处理越来越快），最终也有可能出现问题。
比如，像上面的代码，SemaphoreService2.java 中 semaphore.release(2) 如果改成 semaphore.release(1) 则 就会出现有5个线程得不到运行堆积的情况，可以算一下：6-2-2-2+1+1+1=3，运行完一个回合后，还剩3个通路，3-2+1，第二回合，还剩2个通路，2-2+1=1，第3个回合，还剩一个通路，不足以运行任何一个线程。
把上面说的用代码实现一下，修改 SemaphoreService2.java 如下：

package test_semaphore_2;

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

public class SemaphoreService2 {

	private static SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    private Semaphore semaphore = new Semaphore(6);//6表示有6个通路
    
    public void doSomething() {
        try {
            semaphore.acquire(2); // 2 表示进入此代码，就会消耗2个通路，2个通路从6个中扣除
            System.out.println(Thread.currentThread().getName() + ":doSomething start-" + getFormatTimeStr());
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + ":doSomething end-" + getFormatTimeStr());
            semaphore.release(1); // 释放占用的 2 个通路
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public int availablePermits() {    // 查看可用通路数
        return semaphore.availablePermits();
    }
    
    public static String getFormatTimeStr() {
        return sf.format(new Date());
    }

在这里插入图片描述

  1. acquire 的不可中断实现
    仔细看一下上面的代码，semaphore.acquire() 和 semaphore.acquire(int permits) 是会抛出异常 InterruptedException 的，如果在 acquire 和 release 之间的代码是一个比较慢和复制的运算，如内存占用过多，或者栈深度很深等，jvm会中断这块代码。

如何才能不让 jvm 中断 代码执行呢？

答案是：使用 acquireUninterruptibly() 替换acquire()、使用 acquireUninterruptibly(int permits) 替换 acquire(int permits) 。acquireUninterruptibly 不会抛出 InterruptedException ，一个代码块一时执行不完，还会继续等待执行。

个人觉得，不要随便使用 acquireUninterruptibly ，因为 jvm 中断执行，是自身的一种自我保护机制，保证 java 进程的正常，除了特殊情况必须用 acquireUninterruptibly 外，都应该 使用 acquire ，同时，改进一下 SemaphoreService2 的 doSomething 方法，将 release 放到 finally 块 中，如下。

public void doSomething() {
        try {
            semaphore.acquire(2); // 2 表示进入此代码，就会消耗2个通路，2个通路从6个中扣除
            System.out.println(Thread.currentThread().getName() + ":doSomething start-" + getFormatTimeStr());
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + ":doSomething end-" + getFormatTimeStr());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release(2); // release 放到 finally 中
        }
    }

  1. 其他一些常有工具方法
    availablePermits() 方法在前面用过，表示返回 Semaphore 对象中的当前可用许可数，此方法通常用于调试，因为许可数量（通路）可能是实时在改变的。
    drainPermits() 方法可获取并返回立即可用的所有许可（通路）个数，并将可用许可置为0。
    getQueueLength() 获取等待许可的线程个数。
    hasQueuedThreads() 判断有没有线程在等待这个许可。
    getQueueLength() 和 hasQueuedThreads() 都是在判断当前有没有等待许可的线程信息时使用。

  2. 线程公平性
    上面用的 Semaphore 构造方法是 Semaphore semaphore = new Semaphore(int permits)
    其实，还有一个构造方法： Semaphore semaphore = new Semaphore(int permits , boolean isFair)
    isFair 的意思就是，是否公平，获得锁的顺序与线程启动顺序有关，就是公平，先启动的线程，先获得锁。isFair 不能100% 保证公平，只能是大概率公平。
    isFair 为 true，则表示公平，先启动的线程先获得锁。

  3. 方法 tryAcquire() 、 tryAcquire(int permits)、 tryAcquire(int permits , long timeout , TimeUint unit) 的使用：
    tryAcquire 方法，是 acquire 的扩展版，tryAcquire 作用是尝试得获取通路，如果未传参数，就是尝试获取一个通路，如果传了参数，就是尝试获取 permits 个 通路 、在指定时间 timeout 内 尝试 获取 permits 个通路。
    上代码试试看：
    3个类，线程类未变，以下是修改了的两个类：

package test_semaphore_3;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreService3 {

	private static SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    private Semaphore semaphore = new Semaphore(6,true);//6表示有6个通路
    
    public void doSomething() {
        try {
            if (semaphore.tryAcquire(2, 3, TimeUnit.SECONDS)) { // 在 3秒 内 尝试获取 2 个通路

                System.out.println(Thread.currentThread().getName() + ":doSomething start-" + getFormatTimeStr());
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + ":doSomething end-" + getFormatTimeStr()
                        + "，当前是否有进程等待：" + semaphore.hasQueuedThreads() + "，等待进程数：" + semaphore.getQueueLength());
                semaphore.release(2); // 释放占用的 2 个通路
            } else {
                System.out.println(Thread.currentThread().getName() + ":doSomething 没有获取到锁-准备退出-" + getFormatTimeStr());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public int availablePermits() {    // 查看可用通路数
        return semaphore.availablePermits();
    }
    
    public static String getFormatTimeStr() {
        return sf.format(new Date());
    }
}

package test_semaphore_3;

public class SemaphoreTest3 {

	public static void main(String args[]) {
        SemaphoreService3 service = new SemaphoreService3(); // 使用总 6 通路，每个线程占用2通路
        for (int i = 0; i < 10; i++) {
            MyThread t = new MyThread("thread" + (i + 1), service);
            t.start();// 这里使用 t.run() 也可以运行，但是不是并发执行了 
        }
    }
}

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

  1. 多进路-多处理 vs 多进路-单处理
    在上面的代码中，我们之所以可以实现单处理，是因为在上面的所有线程都共有了同一个 Semaphore 来进行进程处理，那么如果 Semaphore 本身就是进程的一部分呢，会怎么样呢？
    比如，修改 第一个例子中的 SemaphoreTest 如下：
package com.cd.concurrent.semaphore;

public class SemaphoreTest {
    public static void main(String args[]) {
        for (int i = 0; i < 10; i++) {
            SemaphoreService service = new SemaphoreService();
            MyThread t = new MyThread("thread" + (i + 1), service);
            t.start();// 这里使用 t.run() 也可以运行，但是不是并发执行了 
        }
    }
}

结果：
在这里插入图片描述
如果 SemaphoreTest 类不进行修改，如何实现第一个例子 中的 单处理呢？
修改 SemaphoreService ，代码如下：

package test_semaphore_4;

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

public class SemaphoreService {

	private static SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    private Semaphore semaphore = new Semaphore(2);// 同步关键类，构造方法传入的数字是多少，则同一个时刻，只运行多少个进程同时运行制定代码

    public void doSomething() {
        try {
            /**
             * 在 semaphore.acquire() 和 semaphore.release()之间的代码，同一时刻只允许制定个数的线程进入，
             * 因为semaphore的构造方法是1，则同一时刻只允许一个线程进入，其他线程只能等待。
             * */
            semaphore.acquire();
            
            doSomethingMain(); // 将主要处理部分封装成一个方法
            
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    private static synchronized void doSomethingMain() throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + ":doSomething start-" + getFormatTimeStr());
        Thread.sleep(2000);
        System.out.println(Thread.currentThread().getName() + ":doSomething end-" + getFormatTimeStr());
    }

    public static String getFormatTimeStr() {
        return sf.format(new Date());
    }
}

注意：doSomethingMain() 方法必须是 static synchronized 的才行

结果：
在这里插入图片描述
这里，抛出一个问题，上面的代码，不用 synchronized 实现，而使用 ReentrantLock 来实现，按理说会更好的，原因如下：
synchronized 是 jvm 层面的实现，ReentrantLock 是 jdk 层面的实现，synchronized 的缺点如下：

  • 不能响应中断；
  • 同一时刻不管是读还是写都只能有一个线程对共享资源操作，其他线程只能等待
  • 锁的释放由虚拟机来完成，不用人工干预，不过此即使缺点也是优点，优点是不用担心会造成死锁，缺点是由可能获取到锁的线程阻塞之后其他线程会一直等待，性能不高。

而lock接口的提出就是为了完善synchronized的不完美的，首先lock是基于jdk层面实现的接口，和虚拟机层面不是一个概念；其次对于lock对象中的多个方法的调用，可以灵活控制对共享资源变量的操作，不管是读操作还是写操作
那么上面的代码如果使用 ReentrantLock 来实现，岂不是更好吗？好，修改 SemaphoreService：

package test_semaphore_5;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.ReentrantLock;

public class SemaphoreService {

	private static SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    private Semaphore semaphore = new Semaphore(2);// 同步关键类，构造方法传入的数字是多少，则同一个时刻，只运行多少个进程同时运行制定代码

    private ReentrantLock lock = new ReentrantLock();
    
    public void doSomething() {
        try {
            /**
             * 在 semaphore.acquire() 和 semaphore.release()之间的代码，同一时刻只允许制定个数的线程进入，
             * 因为semaphore的构造方法是1，则同一时刻只允许一个线程进入，其他线程只能等待。
             * */
            semaphore.acquire();

            lock.lock();
            doSomethingMain(); // 将主要处理部分封装成一个方法            

            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    private void doSomethingMain() throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + ":doSomething start-" + getFormatTimeStr());
        Thread.sleep(2000);
        System.out.println(Thread.currentThread().getName() + ":doSomething end-" + getFormatTimeStr());
    }

    public static String getFormatTimeStr() {
        return sf.format(new Date());
    }
}

和预期的不一样呀，10个线程基本是同时执行了，那么问题出在哪里呢？
因为使用的不是同一个 SemaphoreService 对象实例，所有是多个锁分别加在了多个 SemaphoreService 实例中，就相当于没有

Desperate_gh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java关于^的坑
weixin_37760377的博客
01-02 640
在平时运算中，大家都习惯^就是“次方运算”，比如10^2 = 100,2^3=8 。但是这在Java中甚至说在计算机中，^并不是表示“次方运算”， 而是表示 二进制位数运算中，如果相对应位值相同，则结果为0，否则为1，也就是计算机中异或运算符 “^”，用于逻辑运算 ^ 如果相对应位值相同，则结果为0，否则为1 如，（60 ^ 13）得到49，即 0011 0001 ...
Java中10的平方
csucoderlee的专栏
06-10 1万+
大晚上的犯困，写了个算法，中间有一步是需要10的c-1次方，顺手就写了个10^(c-1)，结果跑了半天结果都不对。后来打个断点，才发现这里写的有问题，10^2 代表10的二进制与2的二进制进行异或。如果，想计算10的c-1次方，就只能使用math包提供的函数了，Math.pow(10, c-1)...
在Java编程中%和/的区别
m0_63926154的博客
09-11 4809
简单理解：在Java中/可以简单理解为取整，而%为取余。小细节：在js中/不收拾取整会出现小数所以要注意一下。在编程中经常会看到%和/这里要区分一下它俩的区别。
java 声明变量构成_Java语言的变量由哪些组成
weixin_39774490的博客
02-13 576
展开全部public/private/protected类型(四类八种)。变量的定义必须严格按照标识符的命名规则，即0~9数字e68a843231313335323631343130323136353331333433663036、字母、下滑线、$等组成，且首字母不能是数字、不能是java关键字。首字母必须小写，当有多个单词组成时，后面的单词首字母要大写。变量名一般由名词组成。变量定义：[访问修饰...
java怎么表示10 2_java -Xmx1G是否表示10 ^ 9或2 ^ 30字节？
weixin_33167456的博客
02-25 449
小编典典简短的答案：JVM命令行参数使用的所有内存大小均以传统的二进制单位指定，其中千字节为1024字节，其他以1024为底的幂。长答案：在命令行参数的此文档页面上，以下内容适用于所有接受内存大小的参数：例如，设置大小为8 GB，您可以指定8g，8192m，8388608k，或8589934592作为参数。对于-Xmx，它提供了以下特定示例：下面的示例演示如何使用各种单位将分配的最大内存大小设置为...
ojdbc14-10.2.0.2.0.jar.zip
07-22
标题中的"ojdbc14-10.2.0.2.0.jar.zip"是一个包含Oracle JDBC驱动程序的压缩文件，主要用于在Java应用程序中连接到Oracle数据库。Oracle JDBC驱动程序，也称为Oracle Thin Driver，是Java开发人员用来与Oracle数据库...
ojdbc14-10.2.0.3.0.jar
06-13
标题中的"ojdbc14-10.2.0.3.0.jar"是指Oracle JDBC驱动的一个特定版本，这是Oracle数据库与Java应用程序进行交互的重要组件。Oracle JDBC驱动程序允许Java开发者编写程序，以便连接到Oracle数据库，执行SQL查询，...
instantclient-basic-win32-10.2.0.5
09-05
4. `ocijdbc10.dll`：Java数据库连接（JDBC）驱动，使得Java应用程序可以连接到Oracle数据库。 5. `ldap.ora`：LDAP（轻量目录访问协议）配置文件，用于身份验证和授权。 在安装和配置Oracle Instant Client时，...
ojdbc14-10.2.0.1.0 maven java
09-15
1. 连接oracle数据库，版本号为10.2.0.1.0，看清版本号，否则可能导致从远程仓库中失败。 2. 在c盘新建oracle文件夹，将下载好的oracle14.jar放到oracle文件夹中 3.在cmd中运行一下： mvn install:install-file ...
ojdbc14-10.2.0.4.0.jar
12-18
ojdbc14-10.2.0.4.0.jar 是一个Oracle数据库连接驱动的Java档案，主要用于Java应用程序与Oracle数据库之间的通信。这个特定版本的驱动程序是Oracle JDBC驱动程序的一个版本，它对应于Oracle数据库10g的第二版（10.2....
java 10.1/10.2/10.3 总结
qaqaqaerw的博客
10-11 1343
java 三大流程控制 1. 顺序控制 依次执行我们的代码。 2. 条件控制 a. 目的 ： 对程序执行，一些不可预知的流程，进行一个预先判断. b. 条件:条件具有真假的特性。而且只可能为真，或者为假。 c. java条件控制有四种手段: (1)if语句 结构:      if(条件){             //实现我们的逻辑                 } (2
Java每日面试题5
qq_40959750的博客
08-07 118
一、CountDownLatch和CyclicBarrier的区别 1、CountDownLatch用于主线程等待其他子线程任务都执行完毕后再执行，CyclicBarrier用于一组线程相互等待大家都到达某个状态后再同时执行。 public class CountdownLatchExample { public static void main(String[] args) throws InterruptedException { final int totalThread = 10; Cou
关于java位运算符&,~,^,|,<<,>>的整理(包含二进制与十进制的转换)
lsr40的博客
09-18 1万+
要讲java一些奇奇怪怪的运算符号之前，必须先了解二进制，因为这些看不懂的运算符都是基于二进制运算的 计算机里二进制的运算，往往比十进制运算来的快。 首先了解下转换规则（相互转换）： 转码之前，有一些名词概念： 1、原码 一个正数，按照绝对值大小转换成二进制数，称为原码 2、反码 将二进制数按位取反，所得的新二进制数称为原二进制数的反码 其实就是把原码中的0变为1,1变为0
JDK-10.0.2-Windows下载安装
Jaeshn
09-23 2万+
  一、下载     在https://www.oracle.com/technetwork/java/javase/downloads/jdk10-downloads-4416644.html下载，点击接受许可协议后下载对应版本。 二、安装 1、双击打开exe文件，点击下一步 2、点击更改可以改变安装路径 ，由于这里我已经有安装JRE所以安装页面源代码后面没有公共JRE的选项，...
学习记录-1：关于java10.0.2在win10上安装jdk的步骤及注意事项
TetoHY的博客
07-23 5308
笔者之前曾在另一台电脑上配置过java的环境变量，如今换了一台新的电脑首先就卡在了环境变量的配置上。由于时间已经过去了很久，笔者已经忘记了之前配置的具体步骤，如今重新进行环境变量配置，也遇到了一些小麻烦。就此写下此篇博客以记录。 首先还是和大多数网上搜索来的配置变量教程一样，登陆ORACLE官网下载（http://www.oracle.com/technetwork/java/javase/ar...
Java的位运算符详解实例——与（&）、非（~）、或（|）、异或（^）
热门推荐
is_zhoufeng的专栏
10-25 21万+
位运算符主要针对二进制，它包括了：“与”、“非”、“或”、“异或”。从表面上看似乎有点像逻辑运算符，但逻辑运算符是针对两个关系运算符来进行逻辑运算，而位运算符主要针对两个二进制数的位进行逻辑运算。下面详细介绍每个位运算符。   1．与运算符 与运算符用符号“&”表示，其使用规律如下： 两个操作数中位都为1，结果才为1，否则结果为0，例如下面的程序段。 public class dat
最新版本的JDK安装和配置(Java SE 10.0.2)
weixin_30293079的博客
08-19 1361
1.废话少说，要么百度JDK，要么直接点传送门http://www.oracle.com/technetwork/java/javase/downloads/index.html。这里需要说的JDK包含JRE，打个比方，JDK就是厨房，包含各种工具，而JRE是运行环境，就是锅。所以下载的话，直接下载最新JDK最好。然后根据你的系统位数选择版本。我的是64bit. ...
关于Java10.0.2配置环境变量
turbojsc的博客
09-07 1578
                                                                          关于Java10.0.2配置环境变量   在网上找了各种方法一直也没配好打开jak下的lib文件夹发现并没有tools.jar，后经查询jdk-9后就没有了上述.jar文件所以我的配置方法如下 ClASSPATH C:\jdk安装目录\lib C:...
instantclient-basic-win64-10.2.0.5.zip
最新发布
07-07
通过使用 instantclient-basic-win64-10.2.0.5.zip 安装包，用户可以在他们的计算机上轻松地部署 Oracle Instant Client，并使用各种编程语言（如C、C++、Java等）来访问 Oracle 数据库。 安装这个包非常简单。首先...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值