JavaSE|线程安全

最新推荐文章于 2023-12-01 21:47:22 发布
最新推荐文章于 2023-12-01 21:47:22 发布
阅读量297 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/darlingwood2013/article/details/86004836
版权

JavaSE|线程安全

案例与线程安全

两种方式实现模拟电影院售票

需求：某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。

两种方式实现：

  1. 继承Thread类
  2. 实现Runnable接口
// 继承Thread类的方式
public class SellTicketDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		SellTicket st1 = new SellTicket();
		SellTicket st2 = new SellTicket();
		SellTicket st3 = new SellTicket();
		
		st1.setName("窗口1");
		st2.setName("窗口2");
		st3.setName("窗口3");
		
		st1.start();
		st2.start();
		st3.start();

	}

}

public class SellTicket extends Thread {
	
	// 此处一定要用static，共享数据
	private static int ticket = 100;

	@Override
	public void run() {
		while(true){
			if(ticket > 0){
				System.out.println(getName() + "正在售卖第" + (ticket--) + "张票");
			}
		}
	}
}

// 实现Runnable接口方式
public class SellTicketDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		SellTicket st = new SellTicket();
		
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		Thread t3 = new Thread(st, "窗口3");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

public class SellTicket implements Runnable{

	private int ticket = 100;
	@Override
	public void run() {
		while(true){
			if(ticket > 0){
				System.out.println(Thread.currentThread().getName() + "正在售卖第" + (ticket--) + "张票");
			}
		}
		
	}
}

实现Runnable接口的方式比继承Thread类的方式更适合这个案例。三个售票窗口共享同一个剩余票数，使用Thread类时，由于需要创建三个Thread实例，所以必须将剩余票数设置为static的成员变量。而实现Runnable接口的方式中只有一个实现Runnable接口的实例，即共享的数据本来就只有一份，将数据有效分离，代码更优雅。

增加售票延迟

电影院售票程序，从表面上看不出什么问题，但是在真实生活中，售票时网络是不能实时传输的，总是存在延迟的情况，所以，在出售一张票以后，需要一点时间的延迟。
需求：改实现接口方式的卖票程序，每次卖票延迟100毫秒。

public class SellTicketDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		SellTicket st = new SellTicket();
		
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		Thread t3 = new Thread(st, "窗口3");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

public class SellTicket implements Runnable{

	private int ticket = 100;
	@Override
	public void run() {
		while(true){
			if(ticket > 0){
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "正在售卖第" + (ticket--) + "张票");
			}
		}
		
	}
}

相同的票出现多次：
在这里插入图片描述
出现负数结果：
在这里插入图片描述

加入延迟后，我们发现出现了两个问题：

  1. 相同的票出现多次
    CPU的一次操作必须是原子性的
  2. 还出现了负数的票
    随机性和延迟导致的

注意：
线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

解决线程安全问题的基本思想

首先想为什么出现问题?(也是我们判断是否有问题的标准)

  • 是否是多线程环境
  • 是否有共享数据
  • 是否有多条语句操作共享数据

如何解决多线程安全问题呢?
基本思想：让程序没有安全问题的环境。

怎么实现呢?
把多个语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。

同步：解决线程安全问题

解决线程安全问题实现1

即同步代码块。

格式：synchronized(对象){需要同步的代码;}
同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。

同步代码块的对象可以是哪些呢?
下面代码使用的Object，其实可以是任意对象，例如自定义的类等。

同步代码块用obj做锁：

public class SellTicketDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		SellTicket st = new SellTicket();
		
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		Thread t3 = new Thread(st, "窗口3");
		
		t1.start();
		t2.start();
		t3.start();
	}
}
public class SellTicket implements Runnable{

	// 定义100张票
	private int ticket = 100;
	// 定义同一把锁
	private Object obj = new Object();
	@Override
	public void run() {
		while(true){
			synchronized(obj){
				if(ticket > 0){
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "正在售卖第" + (ticket--) + "张票");
				}
			}
		}
		
	}
}

同步代码块用任意对象做锁：

public class SellTicket implements Runnable {

	// 定义100张票
	private static int tickets = 100;

	// 定义同一把锁
	private Demo d = new Demo();
	
	//同步代码块用任意对象做锁
	@Override
	public void run() {
		while (true) {
			synchronized (d) {
				if (tickets > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "正在出售第" + (tickets--) + "张票 ");
				}
			}
		}
	}
	
class Demo {
}

同步的特点

同步的前提：

  • 多个线程
  • 多个线程使用的是同一个锁对象

同步的好处：同步的出现解决了多线程的安全问题。

同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

解决线程安全问题实现2

即同步方法。

格式：把同步关键字加到方法上。

问题：

  1. 同步方法的锁对象是什么呢?
    this

  2. 如果是静态方法，同步方法的锁对象又是什么呢?
    类的字节码文件。

  3. 那么，我们到底使用谁?
    如果锁对象是this，就可以考虑使用同步方法。
    否则能使用同步代码块的尽量使用同步代码块。

同步非静态方法，用this作锁：

public class SellTicket implements Runnable {

	// 定义100张票
	private static int tickets = 100;

	// 定义同一把锁
	private Object obj = new Object();


	private int x = 0;
	

	@Override
	public void run() {
		while (true) {
			if(x%2==0){
				synchronized (this) {
					if (tickets > 0) {
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()
								+ "正在出售第" + (tickets--) + "张票 ");
					}
				}
			}else {			
				sellTicket();				
			}
			x++;
		}
	}


	private synchronized void sellTicket() {
		if (tickets > 0) {
		try {
				Thread.sleep(100);
		} catch (InterruptedException e) {
				e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()
					+ "正在出售第" + (tickets--) + "张票 ");
		}
}
}

同步静态方法，用该类的字节码文件作锁：

public class SellTicket implements Runnable {

	// 定义100张票
	private static int tickets = 100;

	// 定义同一把锁
	private Object obj = new Object();


	private int x = 0;
	

	@Override
	public void run() {
		while (true) {
			if(x%2==0){
				synchronized (SellTicket.class) {
					if (tickets > 0) {
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()
								+ "正在出售第" + (tickets--) + "张票 ");
					}
				}
			}else {			
				sellTicket();				
			}
			x++;
		}
	}


	private static synchronized void sellTicket() {
		if (tickets > 0) {
		try {
				Thread.sleep(100);
		} catch (InterruptedException e) {
				e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()
					+ "正在出售第" + (tickets--) + "张票 ");
		}
}
}

线程安全的类

StringBuffer、Vector、Hashtable都是线程安全的类，通过查看源码我们看到，类中几乎每一个方法都加了synchronized关键字。

Vector是线程安全的时候才去考虑使用的，但是即使要安全，也不用Vector，可以通过Collections集合的静态方法，得到线程安全的集合。例如：
public static List synchronizedList(List list)

public class ThreadDemo {
	public static void main(String[] args) {
		// 线程安全的类
		StringBuffer sb = new StringBuffer();
		Vector<String> v = new Vector<String>();
		Hashtable<String, String> h = new Hashtable<String, String>();

		// Vector是线程安全的时候才去考虑使用的，但是我还说过即使要安全，我也不用你
		// 那么到底用谁呢?
		// public static <T> List<T> synchronizedList(List<T> list)
		List<String> list1 = new ArrayList<String>();// 线程不安全
		List<String> list2 = Collections
				.synchronizedList(new ArrayList<String>()); // 线程安全
	}
}

JDK5中Lock锁的使用

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock。

Lock是一个接口，使用的时候需要实例化为其子类对象。（如ReentrantLock是Lock的实现类）

Lock使用的一般格式：

	 Lock l = ...; 
     l.lock();
     try {
         // access the resource protected by this lock
     } finally {
         l.unlock();
     }

void lock()：获取锁。
void unlock()：释放锁。

将Lock应用在电影院售票程序中如下：

public class SellTicketDemo {
	public static void main(String[] args) {
		// 创建资源对象
		SellTicket st = new SellTicket();

		// 创建三个窗口
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		Thread t3 = new Thread(st, "窗口3");

		// 启动线程
		t1.start();
		t2.start();
		t3.start();
	}
}

public class SellTicket implements Runnable {

	// 定义票
	private int tickets = 100;

	// 定义锁对象
	private Lock lock = new ReentrantLock();

	@Override
	public void run() {
		while (true) {
			try {
				// 加锁
				lock.lock();
				if (tickets > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "正在出售第" + (tickets--) + "张票");
				}
			} finally {
				// 释放锁
				lock.unlock();
			}
		}
	}

}

死锁

同步弊端：1)效率低；2)如果出现了同步嵌套，就容易产生死锁问题
死锁就是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象。

同步代码块的嵌套案例如下：

public class DieLockDemo {
	public static void main(String[] args) {
		DieLock dl1 = new DieLock(true);
		DieLock dl2 = new DieLock(false);

		dl1.start();
		dl2.start();
	}
}

public class MyLock {
	// 创建两把锁对象
	public static final Object objA = new Object();
	public static final Object objB = new Object();
}

public class DieLock extends Thread {

	private boolean flag;

	public DieLock(boolean flag) {
		this.flag = flag;
	}

	@Override
	public void run() {
		if (flag) {
			synchronized (MyLock.objA) {
				System.out.println("if objA");
				synchronized (MyLock.objB) {
					System.out.println("if objB");
				}
			}
		} else {
			synchronized (MyLock.objB) {
				System.out.println("else objB");
				synchronized (MyLock.objA) {
					System.out.println("else objA");
				}
			}
		}
	}
}

生产者-消费者问题

线程间通信

针对同一个资源的操作有不同种类的线程。
举例：卖票有进的，也有出的。

案例：通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作。

等待唤醒机制

Object类中提供了三个方法：
wait()：等待。等待的时候会立即释放锁。将来醒过来的时候，是从该语句位置醒来，即从该位置继续执行。
notify()：唤醒单个线程。唤醒并不意味着被唤醒的进程可以立马执行，还是需要抢CPU执行权。
notifyAll()：唤醒所有线程。（用在多生产多消费中）

问题：为什么这些方法不定义在Thread类中呢?
这些方法的调用必须通过锁对象调用，而我们刚才使用的锁对象是任意锁对象。
所以，这些方法必须定义在Object类中。

/*
 * 分析：
 * 		资源类：Student	
 * 		设置学生数据:SetThread(生产者)
 * 		获取学生数据：GetThread(消费者)
 * 		测试类:StudentDemo
 * 
 * 问题1：按照思路写代码，发现数据每次都是:null---0
 * 原因：我们在每个线程中都创建了新的资源,而我们要求的时候设置和获取线程的资源应该是同一个
 * 如何实现呢?
 * 		在外界把这个数据创建出来，通过构造方法传递给其他的类。
 * 
 * 问题2：为了数据的效果好一些，我加入了循环和判断，给出不同的值,这个时候产生了新的问题
 * 		A:同一个数据出现多次
 * 		B:姓名和年龄不匹配
 * 原因：
 * 		A:同一个数据出现多次
 * 			CPU的一点点时间片的执行权，就足够你执行很多次。
 * 		B:姓名和年龄不匹配
 * 			线程运行的随机性
 * 线程安全问题：
 * 		A:是否是多线程环境		是
 * 		B:是否有共享数据		是
 * 		C:是否有多条语句操作共享数据	是
 * 解决方案：
 * 		加锁。
 * 		注意：
 * 			A:不同种类的线程都要加锁。
 * 			B:不同种类的线程加的锁必须是同一把。
 * 
 * 问题3:虽然数据安全了，但是呢，一次一大片不好看，我就想依次的一次一个输出。
 * 如何实现呢?
 * 		通过Java提供的等待唤醒机制解决。
 * 
 * 等待唤醒：
 * 		Object类中提供了三个方法：
 * 			wait():等待
 * 			notify():唤醒单个线程
 * 			notifyAll():唤醒所有线程
 * 		为什么这些方法不定义在Thread类中呢?
 * 			这些方法的调用必须通过锁对象调用，而我们刚才使用的锁对象是任意锁对象。
 * 			所以，这些方法必须定义在Object类中。
 */
public class StudentDemo {
	public static void main(String[] args) {
		//创建资源
		Student s = new Student();
		
		//设置和获取的类
		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		//线程类
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);

		//启动线程
		t1.start();
		t2.start();
	}
}

public class Student {
	String name;
	int age;
	boolean flag; // 默认情况是没有数据，如果是true，说明有数据
}

public class SetThread implements Runnable {

	private Student s;
	private int x = 0;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				//判断有没有
				if(s.flag){
					try {
						s.wait(); //t1等着，释放锁
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
				if (x % 2 == 0) {
					s.name = "林青霞";
					s.age = 27;
				} else {
					s.name = "刘意";
					s.age = 30;
				}
				x++; //x=1
				
				//修改标记
				s.flag = true;
				//唤醒线程
				s.notify(); //唤醒t2,唤醒并不表示你立马可以执行，必须还得抢CPU的执行权。
			}
			//t1有，或者t2有
		}
	}
}

public class GetThread implements Runnable {
	private Student s;

	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				if(!s.flag){
					try {
						s.wait(); //t2就等待了。立即释放锁。将来醒过来的时候，是从这里醒过来的时候
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
				System.out.println(s.name + "---" + s.age);
				//林青霞---27
				//刘意---30
				
				//修改标记
				s.flag = false;
				//唤醒线程
				s.notify(); //唤醒t1
			}
		}
	}
}

线程的状态转换图

在这里插入图片描述

代码改进

在目前书写的消费者-生产者代码中，学生资源类的属性都是默认的，在实际书写中一般将其用private修饰，所以此处改进。同时由于用private修饰了属性，在类外我们就不能直接对其操作了，应该在Student类中提供相应的Set()和Get()方法。那么这个时候应该怎么同步呢？怎么样才能达到我们预期的效果？（即生产一个消费一个依次循环）

public class StudentDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Student s = new Student();
		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);
		
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);
		
		t1.start();
		t2.start();	

	}
}

// 学生资源类
public class Student {
	
	private String name;
	private int age;
	private boolean flag;
	
	public Student() {

	}

	public synchronized void Set(String name, int age){
		if(this.flag){
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		this.name = name;
		this.age = age;
		
		this.flag = true;
		this.notify();
		
	}
	
	public synchronized void Get(){
		if(!this.flag){
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println(name + "---" + age);
		this.flag = false;
		this.notify();
	}
}

// 生产者
public class SetThread implements Runnable {

	private int x = 0;
	private Student s;
	
	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while(true){
			if(x % 2 == 0){
				s.Set("林青霞", 27);
			}else{
				s.Set("刘意", 30);
			}
			x++;
		}
	}
}

// 消费者
public class GetThread implements Runnable {

	private Student s;
	
	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while(true){
			s.Get();
		}
	}
}

在之前的实现中，我们是在SetThread（生产者）和GetThread（消费者）类中，对需要同步的代码块，使用Student对象，进行同步。现在我们可以直接在Student类中对其Set()和Get()方法使用同步关键字。要想达成生产一个消费一个效果，像之前一样，用flag结合等待唤醒机制即可。

叶晚林
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JavaSE-多线程(实现线程安全的三种方式)
weixin_43958460的博客
09-09 673
多线程的线程安全问题 案例：如何使用多线程实现卖票问题？ 给出100张票，让3个线程一起买票，且保证票的唯一性和合法性 实现方式一：使用同步代码块 public class RunnableImpl implements Runnable{ //定义一个多个线程共享的票源 private int ticket = 100; //创建一个锁对象 Object ob...
Java SE多线程部分--19.线程安全
一叶知秋
09-29 324
1、线程安全 java的内存模型中有主内存和线程的工作内存之分，主内存上存放的是线程共享的变量（实例字段，静态字段和构成数组的元素），线程的工作内存是线程私有的空间，存放的是线程私有的变量（方法参数与局部变量）。线程在工作的时候如果要操作主内存上的共享变量，为了获得更好的执行性能并不是直接去修改主内存而是会在线程私有的工作内存中创建一份变量的拷贝（缓存），在工作内存上对变量的...
javase多线程之线程安全
m0_53653818的博客
05-08 386
1.Volatile关键字的作用 volatile意为容易改变的，可以用来修饰基本类型的变量和引用类型的变量。 修饰基本类型的变量保护内存可见性问题 volatile修饰的变量表示易变的，禁止了jvm的优化，所有要用到的场景，都必须从主内存中直接读取而不能从工作内存中读取。当发生变化时也是第一时间写回主内存而不是工作内存。 import java.util.concurrent.TimeUnit; public class Main { //quit没有被volatile修饰时，线程会一直休眠下
JavaSE之实现多线程和解决线程安全问题
weixin_45217677的博客
06-16 170
多线程，线程安全
线程的同步----解决线程安全问题（Lock锁 — JDK5.0新增）
qq_41005604的博客
07-18 105
线程的死锁问题 死锁 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃 自己需要的同步资源，就形成了线程的死锁 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于 阻塞状态，无法继续 解决方法 专门的算法、原则 尽量减少同步资源的定义 尽量避免嵌套同步 public class ThreadTest { public static void main(String[] args) { StringBuffer s1 = new StringB
Javase | 多线程
最新发布
m0_70720417的博客
12-01 1565
多线程： 1.程序 2.进程 3.线程 4.多线程 5.自定义线程类 : 5.1 继承Thread类 5.2 实现Runnable接口 6.多线程的生命周期及状态转换 新建状态 (New) 就绪状态 (Runnable) 运行状态 (Running) 阻塞状态 (Blocked) 死亡状态 (Terminated) 7.多线程的调度 线程的优先级 线程的休眠 线程的让步 yield() 和 sleep() 的区别 8.多线程同步和通信 8.1 多线程的同步 8.2 多线程通信 .....
JavaSE多线程
09-15
这种机制避免了数据竞争，确保了线程安全。 线程通信是多线程间协调工作的一种方式，Java提供了`wait()`, `notify()`和`notifyAll()`这三个方法来实现线程间的协作。这些方法必须在`synchronized`代码块或方法中...
javase之多线程技术
10-16
- 在Java中，线程安全问题主要由于共享数据和并发访问导致的。从字节码角度分析，需要理解指令重排序和内存模型对多线程的影响。CPU上下文切换时，需确保数据的一致性，避免数据竞争和死锁。 3. **Callable与...
JavaSE 多线程必背程序清单
08-26
本文将详细解析多线程的两种创建方式及其优势，以及线程在内存中的状态，并通过一个购票示例引出多线程安全问题。 **1. 多线程的创建方式** **方式一：继承 Thread 类** - **步骤1.1**：定义一个类，继承自 `...
Java线程：线程安全与不安全
12-22
作为一个Java web开发人员，很少也不需要去处理线程，因为服务器已经帮我们处理好了。记得大一刚学Java的时候，老师带着我们做了一个局域网聊天室，用到了AWT、Socket、多线程、I/O，编写的客户端和服务器，当时做...
JavaSe知识总结：多线程.xmind
10-19
思维导图：含括多线程概念，线程创建开启方式，线程安全，线程状态及常见问题
5个步骤，教你瞬间明白线程和线程安全
热门推荐
CSDN资讯
09-01 9万+
作者 |一个程序员的成长责编 | 胡巍巍记得今年3月份刚来杭州面试的时候，有一家公司的技术总监问了我这样一个问题：你来说说有哪些线程安全的类？我心里一想，这我早都背好了...
JAVA中的线程安全与非线程安全，java面试题，java高级笔试题
agoodcoder777的博客
04-23 580
写在最前面，我总结出了很多互联网公司的面试题及答案，并整理成了文档，以及各种学习的进阶学习资料，免费分享给大家。扫码加微信好友进【程序员面试学习交流群】，免费领取。也欢迎各位一起在群里探讨技术。 转自http://blog.csdn.net/xiao__gui/article/details/8934832 线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时...
Java中线程安全的加一(+1)操作的三种方式
chenkaibsw的专栏
07-07 8559
1.锁分为乐观锁和悲观锁，悲观锁总是假设每次的临界区操作会产生冲突，如果多个线程同时需要访问临界区资源，就宁可牺牲性能让线程进行等待。而乐观锁，它会假设对资源的访问都是没有冲突的，所有的线程都可以在不停顿的状态下持续执行，如果遇到冲突，乐观锁采用的叫做比较交换（CAS Compare And Swap）来鉴别线程冲突，一旦检测到冲突产生，就尝试当前操作直到没有冲突为止 。 2.锁的必要性： 引...
Java文件的命名，Java主类，Java中的public类
笔记本
07-16 1万+
编译和运行 Java 程序 HelloWorld.java 文件： // HelloWorld.java public class HelloWorld{ public static void main(String[] args){ System.out.println("Hello World!"); } } 运行该命令后会生成一个 HelloWorld.class 文件： jav...
Java|从Integer和int的区别认识包装类
笔记本
07-24 8149
Java|Integer和int概述 极客时间的课程中，看到一篇讲Integer和int的区别，其中提到了一些没有想过的设计思路（比如Integer的值缓存），扩展了一些知识。文章不是很详细，编排有点混乱，并且很多地方只是提到了，但没有展开来说，导致我读来觉得好像很棒，但实际还是不知其所以然。所以本文根据该课程，整理课程中提到的关键概念，有这样几个疑问待本文解决： Integer和int的区别，...
Java|Java中int的取值范围是多少
笔记本
07-31 7983
Java 中 int 的取值范围是：-2^31 ~ 2^31-1 大致想一下，int 占 4字节，也就是 32 位，int 是有符号的，最高位为符号位。所以剩下31个位置。 那么我们大胆猜测一下，最大正数应该就是2^31-1。 举个栗子~ 如果是3bit的，其中最高位为符号位，看看它的范围是怎样？ 000 001 010 011 最大为 3 = 2^(3-1)-1 和上面的式子是符合的 100 1...
Spring|Spring概述
笔记本
04-19 2006
Spring|Spring概述Spring 介绍Spring 概念Spring 思想：IoC 和 DIBeanFactory 接口 & ApplicationContext 接口Spring 配置详解Bean 元素Spring 创建对象的方式Spring 的分模块配置Spring 属性注入 Spring 介绍 Spring 是一个分层的JavaSE/EE full-stack （一站式）轻...
JavaWeb| Java连接MySQL的方法以及遇到的问题
笔记本
04-10 1385
环境 JDK 1.8+Tomcat v8.5 mysql-connector-java-8.0.14 MySQL 8.0 Eclipse 4.10.0 连接MySQL的方法 调试没问题的版本： public static Connection getConnection() { Connection connection = null; try { Class.forName("...
JavaSE多线程技术详解及常见问题分析
同步使用的锁是保证线程安全的重要手段之一，可以使用synchronized关键字、ReentrantLock类、ReadWriteLock类等来实现同步锁。同步锁可以保证多个线程在访问共享资源时的互斥性和可见性，避免出现并发问题。 总的来...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值