015.java_多线程

最新推荐文章于 2024-03-20 10:15:00 发布
最新推荐文章于 2024-03-20 10:15:00 发布
阅读量142 收藏 1
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzq1824837536/article/details/79724179
版权

进程：把一个程序在一个数据集上的一次执行称为一个进程。

线程：线程是进程中可独立执行的子任务。一个进程中可以有一个或多个线程。

进程与线程的区别：进程是资源分配单位，线程是调度和执行单位。每一个进程都有自己的主存空间，同一个进程中的线程共享这个主存空间，进程中的所有线程对主存空间都有存取权。

线程的创建和启动

单线程操作：

public class SingleThreadTest {
public static void method1(){
	System.out.println("method1");
}

public static void method2(){
	System.out.println("method2");
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("main方法开始执行");
		SingleThreadTest.method1();
		SingleThreadTest.method2();
		System.out.println("main方法执行结束");
	}

}

运行结果：

main方法开始执行
method1
method2
main方法执行结束

方法执行顺序：main（）方法→method1（）方法→method2（）方法

运行main（）方法的线程通常称为主线程。主线程都是由JVM来启动的

JVM允许应用程序执行时可以同时运行多个线程，通过java.lang.Thread类来实现。

每个线程对象通过run()方法运行，通过star()方法启动。

创建新的线程

两种方法：

1.继承Thread类并重写run()方法

2.实现Runnable接口的类（一般采用这种方法）

import java.net.URL;

public class SingleThreadTest {
public static void method1(){
	System.out.println("method1");
}

public static void method2(){
	System.out.println("method2");
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		System.out.println("main方法开始执行");
//		SingleThreadTest.method1();
//		SingleThreadTest.method2();
//		System.out.println("main方法执行结束");
		System.out.println("main方法开始执行");
		Thread thread1=new MyThread();
		MyRunner mr=new MyRunner();
		Thread thread2=new Thread(mr);//把它的实例作为参数传入Thread类的构造方法
		//启动线程
		System.out.println("启动线程1");
		thread1.start();
		System.out.println("启动线程2");
		thread2.start();
		System.out.println(thread1.isAlive());
		URL url=Thread.currentThread()
				.getContextClassLoader()
				.getResource("");//使用方法链调用方式获取当前classpath的绝对路径URL表示法
		System.out.println(url);
		System.out.println("main方法执行结束");
	}

}

class MyThread extends Thread{//继承Thread类
	public void run(){
		//要在线程中执行的代码
		for(int i=0;i<100;i++){
			System.out.println("MyThread:"+i);
		}
	}
}

class MyRunner implements Runnable{//实现Runnable接口

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++){
			System.out.println("MyRunner:"+i);
		}
		
	}
	
}

运行结果：

main方法开始执行
启动线程1
启动线程2
true
MyThread:0
MyThread:1
MyThread:2
MyThread:3
MyRunner:0
MyThread:4
...
MyThread:99
file:/E:/JavaProject/ThreadProject/bin/
main方法执行结束

Thread类的常用方法

public void star()启动线程，执行后不是立刻启动，而是等待jvm调度
public static Thread currentThread()返回对当前正在执行的线程对象的引用
public ClassLoader getContextClassLoader()返回该线程的上下文ClassLoader
public final boolean isAlive()测试线程是否活着
public Thread.State getState()返回该线程的当前状态，true（可运行状态/等待状态）flase（新建状态/中止状态）
public final String getName()返回该线程的名字
public final void setName(String name)设置该线程的名字
public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程
public final void setPriority(int newPriority)更改线程的优先级
public static void sleep(long milis)throws InterruptedException在指定的毫秒数内让正在执行的进程休眠
public void interrupt()中断线程
public final void join()throws InterruptedException等待该线程终止
public static void yield()暂停当前正在执行的线程对象

URL url=Thread.currentThread()
		.getContextClassLoader()
		.getResource("");//使用方法链调用方式获取当前classpath的绝对路径URL表示法
System.out.println(url);

运行结果：

file:/E:/JavaProject/ThreadProject/bin/

线程分为用户线程和守护线程

守护线程是一种在后台提供通用性支持的线程，在没有其它用户线程运行时，会自动退出。如java垃圾回收线程。

thread.setDaemon(ture)  //把用户线程thred变成守护线程

线程的状态及其转换

一个线程创建后，他总是处于六个生命周期的其中一个状态。JDK中用Thread.State枚举了六种状态：

NEW：新建状态

RUNNABLE：可运行状态  正在jvm中执行

BLOCKED：阻塞状态 受堵塞并等待某个监视器锁的进程

WAITING：等待状态 无限期等待另一个进程执行某个操作

TIMED_WAITING：超时等待状态 等待另一个进程执行指定时间的操作的进程

TERMINATED：中止状态 已退出的进程

多线程的调度和优先级

线程的调度：jvm中提供的线程调度器有抢占式模型和分时间片模型

线程的优先级：优先级分为10级。数字越大，优先级越高。MIN_PRIORITY(1)、MAX_PRIORITY(10)、NORMAL_PRIORITY(5)，可以通过setPriority()方法设置进程优先级、getPriority()方法获取进程的优先级。

为了提高程序的移植性，不建议手动提高优先级。

public class ThreadPriorityTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Thread t0=new Thread(new A());
		Thread t1=new Thread(new A());
		System.out.println("进程t0的优先级："+t0.getPriority());
		System.out.println("进程t1的名字："+t1.getName());
		t0.setPriority(10);
		t0.start();
		t1.start();
	}

}
class A implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++){
			System.out.println(Thread.currentThread().getName()+":"+i);
			//Thread.currentThread()返回当前进程对象的引用
		}
	}
	
}

运行结果：

进程t0的优先级：5
进程t1的名字：Thread-1
Thread-0:0
Thread-0:1
...
Thread-0:98
Thread-0:99
Thread-1:0
Thread-1:1
...
Thread-1:99

线程的控制

线程睡眠  

用于调整线程的执行顺序

public class ThreadSleepTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Thread t0=new Thread(new SleepRunner());
		Thread t1=new Thread(new NormalRunner());
		t0.setPriority(10);//最高优先级
		t0.start();
		t1.start();
	}

}
class SleepRunner implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try{
			Thread.sleep(100);//睡100毫秒
		}catch(InterruptedException e){
			e.printStackTrace();//引发异常的所有方法调用信息
		}
		for(int i=0;i<100;i++){
			System.out.println("SleepRunner:"+i);
		}
	}
	
}
class NormalRunner implements Runnable{
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++)
		System.out.println(Thread.currentThread().getName()+":"+i);
	}
}

运行结果：

Thread-1:0
Thread-1:1
...
Thread-1:99
SleepRunner:0
SleepRunner:1
...
SleepRunner:99

线程让步

public class ThreadYieldTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Thread t0=new Thread(new NormalRunner());
		Thread t1= new Thread(new YieldRunner());
		t0.start();
		t1.start();
	}

}
class NormalRunner implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++)
		System.out.println(Thread.currentThread().getName()+":"+i);
	}
	
}
class YieldRunner implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++){
			if(i%10==0){
				Thread.yield();//暂停 让步给其它进程
			}
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
	
}

运行结果：

...
Thread-1:8
Thread-1:9
Thread-0:6
Thread-0:7
Thread-0:8
Thread-0:9
Thread-0:10
Thread-0:11
Thread-0:12
Thread-0:13
Thread-0:14
Thread-0:15
Thread-0:16
Thread-0:17
Thread-0:18
Thread-0:19
Thread-0:20
Thread-0:21
Thread-1:10
...

线程加入

当线程需要接力来完成某项人物时，join()方法可以可以使两个交叉运行的线程变成顺序执行。

public class ThreadJoinTste {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		Thread t=new Thread(new JoinRunner());
		t.start();
		for (int i=0;i<=50;i++){
			System.out.println("main:"+i);
			try{
				if(i==30){  //在这之前t和main交替运行，当i=30时、只有t进程运行，t运行结束后、main把未完成的运行
				t.join();
				}
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			
		}
	}

}
class JoinRunner implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++){
			System.out.println("JoinRunner:"+i);
		}
//		try{
//			Thread.sleep(10);//先让main线程先运行
//		}catch(InterruptedException e){
//			e.printStackTrace();
//		}
	}
	
}

多线程的同步

如果一个程序中定义多个线程，同时对程序中的变量进行访问，赋值修改等，那么这么线程会影响对方的运行。可以对访问进行同步解决。

使用关键词synchronized来同步方法（使用synchronized修饰方法）或同步代码块（synchronized（this）{ 同步代码块 }，这种办法效率较高）、或者使用对象锁将代码块锁住。

public class TrickOfficeTest {
	public static void main(String[] args){
	//五个卖票处  一共1000张票
		SellTrickRunner sell=new SellTrickRunner();
	Thread t1=new Thread(sell);
	t1.setName("售票处1");
	t1.start();
	Thread t2=new Thread(sell);
	t2.setName("售票处2");
	t2.start();
	Thread t3=new Thread(sell);
	t3.setName("售票处3");
	t3.start();
	Thread t4=new Thread(sell);
	t4.setName("售票处4");
	t4.start();
	Thread t5=new Thread(sell);
	t5.setName("售票处5");
	t5.start();
	}
}
class SellTrickRunner implements Runnable{
	private int trickNumber=0;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		boolean flag=true;
		while(flag){
			flag=sell();
		}
	}
public  boolean sell(){  //同步售票方法
	boolean flag=true;
	synchronized(this){//JVM会保证线程执行synchronized代码块时不会被其它线程打断
	if(trickNumber<1000){
		trickNumber=trickNumber+1;//两个线程同时对共享数据操作，就会出错。
		System.out.println(Thread.currentThread().getName()+"卖出第"+trickNumber+"张票。");
	}else{
		flag=false;
	}
	try{
		Thread.sleep(15);//睡眠5秒 增大出错几率
	}catch(InterruptedException e){
		e.printStackTrace();
	}
	return flag;
	}
	
	}	
}

private Lock lock=new ReentrantLock();//创建Lock实例
lock.lock();
	if(trickNumber<1000){
		trickNumber=trickNumber+1;//两个线程同时对共享数据操作，就会出错。
		System.out.println(Thread.currentThread().getName()+"卖出第"+trickNumber+"张票。");
	}else{
		flag=false;
	}
	lock.unlock();

运行结果：

售票处1卖出第1张票。
售票处2卖出第2张票。
售票处3卖出第3张票。
...
售票处4卖出第998张票。
售票处1卖出第999张票。
售票处3卖出第1000张票。

死锁

转自：https://www.cnblogs.com/mudao/p/5867107.html

/*创建两个字符串a和b，
 * 再创建两个线程A和B，
 * 让每个线程都用synchronized锁住字符串（A先锁a，再去锁b；B先锁b，再锁a），
 * 如果A锁住a，B锁住b，A就没办法锁住b，B也没办法锁住a，
 * 这时就陷入了死锁。*/
public class DeadLock {
    public static String obj1 = "obj1";
    public static String obj2 = "obj2";
    public static void main(String[] args){
        Thread a = new Thread(new Lock1());
        Thread b = new Thread(new Lock2());
        a.start();
        b.start();  //如果只让a运行，就可以无限循环锁住
    }    
}
class Lock1 implements Runnable{
    @Override
    public void run(){
        try{
            System.out.println("Lock1 running");
            while(true){
                synchronized(DeadLock.obj1){
                    System.out.println("Lock1 lock obj1");
                    Thread.sleep(3000);//获取obj1后先等一会儿，让Lock2有足够的时间锁住obj2
                    synchronized(DeadLock.obj2){
                        System.out.println("Lock1 lock obj2");//B把obj2锁住了  A不能锁住 所以不能运行
                    }
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
class Lock2 implements Runnable{
    @Override
    public void run(){
        try{
            System.out.println("Lock2 running");
            while(true){
                synchronized(DeadLock.obj2){
                    System.out.println("Lock2 lock obj2");
                    Thread.sleep(3000);
                    synchronized(DeadLock.obj1){
                        System.out.println("Lock2 lock obj1");
                    }
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
Lock1 running
Lock2 running
Lock1 lock obj1
Lock2 lock obj2

解决死锁问题：加大锁的颗粒度，把各个资源的操作代码放在一个同步块内
 

线程交互

java.lang.Object类提供了wait、notify、notifyAll方法用于同步机制，但只能在synchronized方法、synchronized代码块和Lock里面用，否则会报错。

wait方法调用、当前线程将被中断运行，并且放弃该对象的锁。

notify方法调用，会唤醒并运行在此对象等待池中的某个线程。

notifyAll方法会唤醒所有等待这个对象的线程，使之称为可运行的线程

/*生产者消费者问题*/
public class ProductTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Repertory repertory=new Repertory();
		new Thread(new Producer(repertory)).start();
		new Thread(new Consumer(repertory)).start();
	}

}
class Repertory{//仓库
	private int product=0;//默认有0个商品
	public synchronized void addProduct(){ //生产者把产品放入仓库
		if(this.product>=5){
			try{
				this.wait();//满了
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}else{
			product++;
			System.out.println("生产者生产第"+product+"件商品");
			this.notifyAll();//通知等候区的消费者取商品
		}
	}
	public synchronized void getProduct(){//消费者从仓库拿东西
		if((this.product)<=0){
			try{this.wait();//缺货
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}else{
			System.out.println("消费者取走了第"+product+"件商品");
			this.product--;
			this.notifyAll();
		}
	}
}

class Producer implements Runnable{
	private Repertory repertory;
	public Producer(Repertory repertory) {
		this.repertory=repertory;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("生产者开始生产商品");
		while(true){
			try{
				Thread.sleep((int)(Math.random()*10)*100);//Math.random()返回带正号的double值  [0.0,1.0)
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			repertory.addProduct();
		}
	}
	
}

class Consumer implements Runnable{
	private Repertory repertory;
	public Consumer(Repertory repertory) {
		this.repertory=repertory;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("消费者开始取走商品");
		while(true){
			try{
				Thread.sleep((int)(Math.random()*10)*100);//Math.random()返回带正号的double值  [0.0,1.0)
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			repertory.getProduct();
		}
	}
	
}

运行结果：

生产者开始生产商品
消费者开始取走商品
生产者生产第1件商品
消费者取走了第1件商品
生产者生产第1件商品
消费者取走了第1件商品
生产者生产第1件商品
消费者取走了第1件商品
生产者生产第1件商品
生产者生产第2件商品
消费者取走了第2件商品
生产者生产第2件商品
生产者生产第3件商品
生产者生产第4件商品
...

用Timer类调度任务

java.util.Timer类用于执行定时任务

java.util.TimerTask用于创建定时任务

创建定时任务：继承TimerTask类并重写run()方法，将任务内容写在方法体内

执行定时任务：Timer类常用方法：

public void schedule(TimerTask task,long delay,long period):重复地以固定的延迟时间去执行一个任务。

public void scheduleAtFixedRate(TimerTask task,long delay,long period):重复地以固定的频率去执行一个任务。

public void cancle();终止此计时器

import java.util.Timer;
import java.util.TimerTask;

public class TimerTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Timer timer=new Timer();//创建一个计时器
//		timer.schedule(new MyTask(), 0,1000);//立刻执行  每隔   1000毫秒 = 1s 执行一次
		timer.scheduleAtFixedRate(new MyTask(), 0, 1000);
		try{
			Thread.sleep(10000);//主线程睡眠10s
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		timer.cancel();
	}

}
class MyTask extends TimerTask{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("起床");
	}
	
}

运行结果：

起床
起床
起床
起床
起床
起床
起床
起床
起床
起床

打字员小张
关注
专栏目录
java多线程嵌套_Java多线程进阶
weixin_36002897的博客
02-16 4263
需要理解锁是什么意思?首先是发生在多线程的情况下;线程a,线程b,共享资源share例如,share的资源一次只能被一个对象操作,这时候需要一个东西来标识(也叫监视器)出来表明该资源已经有人(指的是线程)在使用了,请还要使用的人(指的是线程)进入等待(线程等待池/队列);怎么实现呢?synchronized关键字,配合一个唯一的东西,可以是类.class,也可以是对象本身;但注意的是必须是一个引用...
JAVA-JavaThreadProgramming-Sams.zip_JAVA 设计_java 多线程_java 线程_多线程
09-14
Java多线程允许程序同时执行多个任务，这极大地提高了程序的效率和响应性。在Java中，线程可以分为两类：用户线程和守护线程。用户线程是应用程序的主要执行单元，而守护线程则服务于用户线程，如垃圾收集器就是典型...
万字图解Java多线程
热门推荐
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java售票任务_多线程详细实现
qq_40285647的博客
06-12 2738
Java售票任务_多线程详细实现 题目回顾：铁道部发布了一个售票任务，要求销售1000张票，要求有3个窗口来进行销售，请编写多线程程序来模拟这个效果。 ​ i. 窗口001正在销售第1000张票 ​ ii. 窗口001正在销售第999张票 ​ iii. 窗口002正在销售第998张票 ​ iv. … ​ v. 窗口002正在销售第1张票 ​ vi. 票已经销售完毕 一 、注意细节： ​ 问题1：三个线程都卖了1000张票，一共卖了3000张票 ​ 原因：三个线程代表三个对象，就有三个成
Java多线程并发编程技术详解
最新发布
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 3万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
Java多线程导出Excel示例
cl617287的博客
03-02 1263
Java多线程导出Excel示例
Java 多线程的应用场景
才哈哈的博客主页
05-01 1万+
电影院新片首映，观影人数大量增加，为提高日营业额，线下售票窗口由原单窗口调整为3窗口，设计一段简单的程序模拟该售票过程。
Java实现多线程有几种方式(满分回答)
Gang-bb的博客
02-22 5844
Java实现多线程有几种方式
【Java多线程】停止线程
一定要站在自己热爱的生活里闪闪发光
10-03 5万+
目录 1. 停止线程的方法 2. 判断线程是否是停止状态 3. 能停止的线程——异常法 4. 在沉睡中停止 5. 能停止的线程——暴力停止 6. 方法stop()与java,lang.ThreadDeath异常 7. 使用return停止线程 1. 停止线程的方法 在Java中有以下3种方法可以终止正在进行的线程： 1）使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。 2）使用stop方法强行终止线程，但是不推荐使用这个方法，因为stop和suspend及resum
java 多线程合并结果集_java多线程-合并
weixin_39949607的博客
02-25 2203
java多线程-合并线程合并的意义就是几个并行的线程合并为一个单线程执行，应用于一个线程必须等待另个线程执行完毕后执行例题：现有一个主线程，T1,T2怎么让T2在T1之后执行，主线程在T2之后执行package cn.thread;public class ThreadJoin {public static void main(String[] args) {ThreadJoin join = n...
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5710
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
java_type_train.rar_java 多线程_java 打字 程序_train_线程
09-23
本资源“java_type_train.rar”提供了一个关于Java多线程和打字程序的训练材料，特别适合想要提升这方面技能的学习者。 多线程在Java中的实现主要有两种方式：通过继承Thread类或实现Runnable接口。当创建一个新...
tcp_test.rar_java tcp 多线程_java tcp 线程_tcp 多线程_tcp线程_多线程 TCP
09-14
本项目"tcp_test.rar"似乎是一个关于Java实现TCP多线程传输的实例，它涵盖了发送方和接收方的并发处理。 首先，让我们了解TCP多线程的概念。在单线程TCP服务器中，服务器接收到一个客户端连接后，会阻塞等待该连接...
FtpUtils.java_java多线程
12-11
ftp上传下载文件方法，自己正在用的可用
net.rar_java 聊天_java 通讯 多线程_白板
09-23
标题中的“net.rar_java 聊天_java 通讯 多线程_白板”表明这是一个关于Java编程的项目，具体涉及网络通信、聊天功能、多线程以及白板同步。这个项目很可能是一个简单的点对点（P2P）通信应用程序，用户可以通过它...
008.java_方法覆盖、多态和抽象类
记录生活
03-20 578
方法覆盖当父类的方法不能满足子类的需求、子类可以对这个方法进行重写、以覆盖父类中的方法。方法覆盖要求：1.子类定义的新方法（覆盖方法）和父类中被覆盖的方法要在返回类型、名称和参数列表上保持一致。2.可选的@Override备注注意：类方法（静态方法）是无法覆盖的，但可以隐藏。package lesson008; public class HideStaticMethodTest { pub...
005.java_继承、super关键字
记录生活
03-18 363
继承 Inheritance  继承是一种由已存在的类型创建一个或多个子类型的机制，即在现有类的基础上构建子类    访问控制符[修饰符]class 类名 extends 父类名{   ...  }    子类拥有父类所有属性和方法。  子类不拥有父类的构造器  父类不拥有子类所特有的属性和方法    继承的优点：  可以创建更为特殊的类型  可提高代码的重用性  提高程序的可维护性  Empl...
014.java_国际化相关类、正则表达式相关类和大数字操作
记录生活
03-27 352
国际化相关类1.java.util.Local类Locale类的对象代表特定的地理、政治和文化地区。有三种获取Local对象的方式。1.使用构造器public Locale(String language,String country)2.利用Locale常用语言环境预设的常量来创建。Locale locale=Locale.CHINA;//获取代表中国大陆的Locale对象3.获取此JVM当前默...
012.java_java.lang包
记录生活
03-23 333
java.lang包中包含了java语言所需要的最基本的功能类和接口，是进行java语言编程的基础。Object类Object类是java语言中所有类的父类，一共定义11个方法。1.equals( )方法public boolean equals(Object obj);  //比较指定的参数对象是否与当前对象相等。  根据两个对象的哈希码值决定2.hashCode( )方法public int ...
Java多线程编程详解
Java多线程机制提供了强大的并发能力，允许开发者编写高效的并发程序。理解和掌握这些知识点对于Java开发人员来说至关重要，有助于在实际项目中处理复杂的并发问题，提升程序的性能和用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值