Java多线程基础

最新推荐文章于 2024-03-10 23:38:03 发布
最新推荐文章于 2024-03-10 23:38:03 发布
阅读量72 收藏
点赞数
分类专栏： Java基础 多线程并发 文章标签： java 运维 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenguangyun123/article/details/84228576
版权

    Java编写的程序都运行在 Java 虚拟机 (JVM) 中，在 JVM 的内部，程序的多任务是通过多线程来实现的。每用 java 命令启动一个 java 应用程序，就会启动一个 JVM 进程。在同一个 JVM 进程中，有且只有一个进程，就是它自己。在这个 JVM 环境中，所有程序代码的运行都是以线程来运行。

    对于一个进程中的多个线程来说，多个线程共享进程的内存块，当有新的线程产生的时候，操作系统不分配新的内存，而是让新线程共享原有的进程块的内存。因此，线程间的通信 很容易，速度也很快。不同的进程因为处于不同的内存块，因此进程之间的通信相对困难。

 

实现多线程的两种方式

    一种是继承 Thread类，一种是实现 Runnable 接口。使用线程的时候主要注意下面两点，一是如何指定线程需要执行的方法，二是如何启动一个线程。新线程的创建跟启动都是通过java代码来触发的，是由java代码通知java平台，java平台再启动线程，启动新线程是一个很短的过程，对于主线程来说，只是通知java平台要启动新线程，通知完了就继续执行代码，不需要等待新线程结果，只有所有线程都退出了，程序才退出。 Thread是定义中 java.lang 包中的，一个类只要继承了 Thread 类并且重写了 run 方法，就可以实现多线程操作，如 下定义的MyThread 类，继承 Thread 类并重写 run 方法： 

public class MyThread extends Thread {	
	private String	name;	
	public MyThread(String name) {		
		this.name = name;		
	}	
	public void run() {		
		for (int i = 0; i < 10; i++) {			
			System.out.println("name:" + name + ",i=" + i);			
		}		
	}	
}
 

  操作类 MyThreadTest： 

public class MyThreadTest{	
	public static void main(String[] args) {		
		MyThread thread1 = new MyThread("线程A");		
		MyThread thread2 = new MyThread("线程B");		
		thread1.run();
		thread2.run();		
	}	
}
 

运行结果如下：

name:线程A,i=0

name:线程A,i=1

name:线程A,i=2

name:线程A,i=3

name:线程A,i=4

name:线程A,i=5

name:线程A,i=6

name:线程A,i=7

name:线程A,i=8

name:线程A,i=9

name:线程B,i=0

name:线程B,i=1

name:线程B,i=2

name:线程B,i=3

name:线程B,i=4

name:线程B,i=5

name:线程B,i=6

name:线程B,i=7

name:线程B,i=8

name:线程B,i=9

 

    发现程序的运行是先运行线程 A完成后再运行线程 B ，不是交替运行，说明程序不是按多线程方式运行，而是按单线程方式运行，正确的启动多线程操作方法应该是调用 start() 方法， JVM 会自动调用该对象的 run() 方法，如上把线程操作类My ThreadTest 类的 run ()方法改为 start ()方法后，执行结果如下：

name:线程A,i=0

name:线程B,i=0

name:线程A,i=1

name:线程B,i=1

name:线程A,i=2

name:线程B,i=2

name:线程A,i=3

name:线程B,i=3

name:线程A,i=4

name:线程B,i=4

name:线程A,i=5

name:线程B,i=5

name:线程A,i=6

name:线程B,i=6

name:线程A,i=7

name:线程B,i=7

name:线程A,i=8

name:线程B,i=8

name:线程A,i=9

name:线程B,i=9

此时已经可以实现多线程调用，但是使用继承Thread 类实现多线程有个限制， java 语言只能继承一个类，而不能多继承，此时可以使用第二种方式实现，就是实现 Runnable 接口。 开发中很少使用继承Thread 类实现多线程操作的，一般都使用实现 Runnable 接口，如下实现多线程类 MyRunnable ： 

public class MyRunnable implements Runnable {  
    private String name;      
    public MyRunnable(String name) {  
        this.name = name;  
    }     
    public void run() {  
        for (int i = 0; i < 10; i++) {  
            System.out.println("name:" + name + ",i=" + i);  
        }  
    }  
}
 

  多线程操作类：

public class MyRunnableTest{  
    public static void main(String[] args) {  
        MyRunnable thread1 = new MyRunnable("线程A");  
        MyRunnable thread2 = new MyRunnable("线程B");  
        new Thread(thread1).start();  
        new Thread(thread2).start();  
    }  
}
 

    实现Runnable 接口实现的多线程类并没有 start() 方法，而是使用 Thread 类的代理来实现多线程的操作。Thread类中有一个类型为Runnable的属性为target，Thread类中的run()方法就是调用该 Runnable 属性的run()方法，如下： 

    private Runnable target;    
    ......
    public void run() {
	if (target != null) {
	    target.run();
	}
    }
 

继承Thread 类实现的多线程不能实现资源共享，而实现 Runnable 接口实现的多线程可以实现资源共享。 如下使用继承Thread 实现的多线程类 MyThread ，模拟卖票场景操作类变量 ticket ： 

public class MyThread extends Thread {	
	private int	ticket	= 5;	
	public void run() {		
		for (int i = 0; i < 50; i++) {			
			if (ticket > 0) {				
				System.out.println("卖票:tichek=" + ticket--);				
			}			
		}		
	}	
}
   多线程操作类为：

 

public class ThreadTicket {	
	public static void main(String[] args) {		
		MyThread thread1 = new MyThread();		
		MyThread thread2 = new MyThread();		
		MyThread thread3 = new MyThread();		
		thread1.start();		
		thread2.start();		
		thread3.start();		
	}	
}
程序输出为：

卖票:tichek=5

卖票:tichek=4

卖票:tichek=3

卖票:tichek=5

卖票:tichek=4

卖票:tichek=5

卖票:tichek=4

卖票:tichek=3

卖票:tichek=2

卖票:tichek=1

卖票:tichek=3

卖票:tichek=2

卖票:tichek=1

卖票:tichek=2

卖票:tichek=1

发现每个线程都操作ticket 变量 5 次，而不是操作一个共享变量，因为这里实例化了3个MyThread对象，把 MyThread 的多线程实现改为实现 Runnable 接口，如： 

public class ThreadTicket {	
	public static void main(String[] args) {		
		MyRunnable thread1 = new MyRunnable();		
		new Thread(thread1).start();		
		new Thread(thread1).start();		
		new Thread(thread1).start();		
	}	
}

输出为：

卖票:tichek=5
卖票:tichek=3
卖票:tichek=2
卖票:tichek=1
卖票:tichek=4
说明 3 个线程操作的是一个变量，因为这里只实例化了一个MyRunnable对象。

 

 

多线程中所有操作方法都是在Thread 类中定义的，如：

设置设置线程名称方法：

1、 使用set 方法： public final void setName(String name)

2、 构造方法：public Thread(Runnable target,String name),

             public Thread(String name);

取得名字：public final String getName();

对于线程的名字，最好是在线程启动前进行设置，最好不要设置相同名字，也不要为一个线程改名字。

Thread类还提供一个静态方法来获取当前操作的线程： public static Thread currentThread();

如下线程实现类：

public class MyRunnable implements Runnable {	
	public void run() {
		for (int i = 0; i < 10; i++) {			
			System.out.println(Thread.currentThread().getName() + " 正在运行...");
		}		
	}	
}
 

  线程操作类：

public class ThreadNameDemo {	
	public static void main(String[] args) {		
		MyRunnable myrunnable = new MyRunnable();		
		Thread thread1 = new Thread(myrunnable, "线程A");		
		Thread thread2 = new Thread(myrunnable, "线程B");		
		Thread thread3 = new Thread(myrunnable, "线程C");		
		thread1.start();		
		thread2.start();		
		thread3.start();		
	}	
}
 

运行输出：

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程B 正在运行...

线程B 正在运行...

线程B 正在运行...

线程B 正在运行...

线程B 正在运行...

线程B 正在运行...

线程B 正在运行...

线程B 正在运行...

线程B 正在运行...

线程B 正在运行...

线程C 正在运行...

线程C 正在运行...

线程C 正在运行...

线程C 正在运行...

线程C 正在运行...

线程C 正在运行...

线程C 正在运行...

线程C 正在运行...

线程C 正在运行...

线程C 正在运行...

把线程实现类改成：

public class ThreadNameDemo {	
	public static void main(String[] args) {		
		MyRunnable myrunnable = new MyRunnable();		
		Thread thread1 = new Thread(myrunnable, "线程A");		
		thread1.start();		
		myrunnable.run();		
	}	
}
 

运行输出：

main 正在运行...

main 正在运行...

main 正在运行...

main 正在运行...

main 正在运行...

main 正在运行...

main 正在运行...

main 正在运行...

main 正在运行...

main 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

线程A 正在运行...

说明在程序运行时，主方法就是一个主 mail线程。

 

Thread类的 sleep() 方法实现线程的休眠，如下线程实现类： 


public class MyRunnable implements Runnable {	
	public void run() {		
		for (int i = 0; i < 5; i++) {			
			try {				
				Thread.sleep(300);				
			}
			catch (InterruptedException e) {				
				// TODO : handle exception				
			}			
			System.out.println(Thread.currentThread().getName() + " 正在运行...");			
		}		
	}	
}
 

线程操作类为：

public class ThreadSleepDemo {	
	public static void main(String[] arge) {
		MyRunnable myrunnable = new MyRunnable();		
		new Thread(myrunnable, "线程A").start();		
		new Thread(myrunnable, "线程B").start();		
	}	
}
 

运行结果为：

线程B 正在运行...

线程A 正在运行...

线程B 正在运行...

线程A 正在运行...

线程B 正在运行...

线程A 正在运行...

线程B 正在运行...

线程A 正在运行...

线程B 正在运行...

线程A 正在运行...

 

Thread类提供 interrupt() 类提供中断线程的执行。

 

Thread类提供 public   final   void   setPriority ( int  newPriority)  方法设置线程优先级，线程优先级有下面三种：

最高： MAX_PRIORITY     10

中等： NORM_PRIORITY    5

最低： MIN_PRIORITY     1

Main线程的优先级为 5

 

线程同步

使用上面模拟卖票程序，如果卖票程序中加入延迟，则运行的效果跟之前的不一样，如：

public class MyRunnable implements Runnable {	
	private int	ticket	= 5;	
	public void run() {		
		for (int i = 0; i < 50; i++) {			
			if (ticket > 0) {				
				try {					
					Thread.sleep(300);					
				}
				catch (InterruptedException e) {					
					// TODO Auto-generated catch block					
					e.printStackTrace();					
				}				
				System.out.println("卖票:tichek=" + ticket--);				
			}			
		}		
	}	
}
 

  线程操作类不变：

public class ThreadTicket {	
	public static void main(String[] args) {		
		MyRunnable myrunnable = new MyRunnable();		
		new Thread(myrunnable).start();		
		new Thread(myrunnable).start();
		new Thread(myrunnable).start();		
	}	
}
 

运行结果为：

卖票:tichek=5

卖票:tichek=3

卖票:tichek=4

卖票:tichek=2

卖票:tichek=1

卖票:tichek=0

卖票:tichek=-1

 

在 java中可以通过同步代码进行代码的加锁操作，有两种实现方法：

1、 同步代码块

使用synchronized 关键字进行同步代码块声明，但是在此操作时必须要明确指出到底锁定的是哪个对象，一般都是以当前对象 this 为主，如上面模拟卖票代码，加上同步后为： 

public class MyRunnable implements Runnable {	
	private int	ticket	= 5;	
	public void run() {		
		for (int i = 0; i < 50; i++) {			
			synchronized (this) {				
				if (ticket > 0) {					
					try {						
						Thread.sleep(300);						
					}
					catch (InterruptedException e) {						
						// TODO Auto-generated catch block						
						e.printStackTrace();						
					}					
					System.out.println("卖票:tichek=" + ticket--);					
				}				
			}			
		}		
	}	
}
  此时输出正常，但是输出速度明显变慢。

 

2、 同步方法

模拟上面卖票程序，改用同步方法实现为：

public class MyRunnable implements Runnable {	
	private int	ticket	= 5;	
	public void run() {		
		for (int i = 0; i < 50; i++) {			
			sale();			
		}		
	}	
	public synchronized void sale() {		
		if (ticket > 0) {			
			try {				
				Thread.sleep(300);				
			}
			catch (InterruptedException e) {				
				// TODO Auto-generated catch block				
				e.printStackTrace();				
			}			
			System.out.println("卖票:tichek=" + ticket--);			
		}
		
	}
	
}
 

在程序中过多的同步为出现死锁，关于Java中锁机制和synchronized关键字看下面两篇文章:

http://chenzehe.iteye.com/blog/1741046

http://chenzehe.iteye.com/blog/1766790

 

 

生产者和浪费者，生产者不断生产内容，消费者不断取出内容，如下基础类Info ，生产者和消费者不断对其进行操作： 


public class Info {	
	private String	country;	
	private String	city;	
	public String getCountry() {		
		return country;		
	}	
	public void setCountry(String country) {		
		this.country = country;		
	}	
	public String getCity() {		
		return city;		
	}	
	public void setCity(String city) {		
		this.city = city;		
	}	
}

//生产者，不断的对Info 对象设值：
public class Product implements Runnable {	
	private Info	info	= null;	
	public Product(Info info) {		
		this.info = info;		
	}	
	public void run() {		
		for (int i = 0; i < 10; i++) {			
			if (i % 2 == 1) {				
				info.setCountry("中国");				
				try {				
					Thread.sleep(300);					
				}
				catch (InterruptedException e) {					
					// TODO Auto-generated catch block					
					e.printStackTrace();					
				}				
				info.setCity("杭州");				
			}
			else {				
				info.setCountry("美国");				
				try{
                                        Thread.sleep(300);					
				}
				catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				info.setCity("硅谷");
			}			
		}		
	}	
}

//消费者，不断的对 Info对象取值 ：
public class Customer implements Runnable {	
	private Info	info	= null;	
	public Customer(Info info) {		
		this.info = info;		
	}	
	public void run() {		
		for (int i = 0; i < 10; i++) {			
			try {				
				Thread.sleep(300);				
			}
			catch (InterruptedException e) {				
				// TODO Auto-generated catch block				
				e.printStackTrace();				
			}			
			System.out.println("country:" + info.getCountry() + "->city:"
			+ info.getCity());			
		}		
	}	
}

//多线程操作类：
public class ProCusDemo {	
	public static void main(String[] args) {		
		Info info = new Info();		
		Product product = new Product(info);		
		Customer customer = new Customer(info);		
		new Thread(product).start();		
		new Thread(customer).start();		
	}	
}
 

运行输出为：

country:中国->city:硅谷

country:美国->city:杭州

country:中国->city:硅谷

country:美国->city:杭州

country:中国->city:硅谷

country:美国->city:杭州

country:中国->city:硅谷

country:美国->city:杭州

country:中国->city:硅谷

country:中国->city:杭州

上面代码出现了生产的内容有可能不一至的情况，还出现了重复取值和重复设值的情况，为了保证数据的完整性，一般加入同步操作，如 Info类加入同步方法后为： 

public class Info {
	private String country;
	private String city;
	public synchronized void set(String country, String city) {
		this.country = country;
		try {
			Thread.sleep(300);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.city = city;
	}
	public synchronized void get() {
		try {
			Thread.sleep(300);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("country:" + this.country + "->city:" + this.city);
	}
	public String getCountry() {
		return country;
	}
	public void setCountry(String country) {
		this.country = country;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
}
生产者为：
public class Product implements Runnable {
	private Info info = null;
	public Product(Info info) {
		this.info = info;
	}
	public void run() {
		for (int i = 0; i < 10; i++) {
			if (i % 2 == 1) {
				info.set("中国", "杭州");
			} else {
				info.set("美国", "硅谷");
			}
		}
	}
}
消费者为：
public class Customer implements Runnable {
	private Info info = null;
	public Customer(Info info) {
		this.info = info;
	}
	public void run() {
		for (int i = 0; i < 10; i++) {
			info.get();
		}
	}
}
多线程操作类不变，输出为：

 

country:美国->city:硅谷

country:中国->city:杭州

country:中国->city:杭州

country:中国->city:杭州

country:中国->city:杭州

country:中国->city:杭州

country:中国->city:杭州

country:中国->city:杭州

country:美国->city:硅谷

country:中国->city:杭州

此时能够保证代码的一至性，但还是存在重复取和重复设置问题，可以使用Object 类的 wait() 方法和 notiry() 方法进行修改，如： Info类为： 

public class Info {
	private String country;
	private String city;
	private boolean flag = true; // true表示可以生产，但不能消费，false表示可以消费，但不能生产
	public synchronized void set(String country, String city) {
		if (!flag) {
			try {
				super.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		this.country = country;
		try {
			Thread.sleep(300);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.city = city;
		this.flag = false;
		super.notify();
	}
	public synchronized void get() {
		if (flag) {
			try {
				super.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("country:" + this.country + "->city:" + this.city);
		this.flag=true; 
		super.notify();
	}
	public String getCountry() {
		return country;
	}
	public void setCountry(String country) {
		this.country = country;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
}
 

其它类不变，运行结果为：

country:美国->city:硅谷

country:中国->city:杭州

country:美国->city:硅谷

country:中国->city:杭州

country:美国->city:硅谷

country:中国->city:杭州

country:美国->city:硅谷

country:中国->city:杭州

country:美国->city:硅谷

country:中国->city:杭州

 

 

chenzehe
关注
专栏目录
Java多线程干货系列（1）Java多线程基础编程开发技术
11-22
Java多线程是Java编程中的重要...以上内容仅涵盖了Java多线程基础编程的一部分知识点，实际开发中还需要关注更多的并发控制策略、性能优化和调试技巧。对于深入理解Java多线程，还需要学习和实践更多相关的高级特性。
Java多线程基础-01、数组概述.rar
11-20
本资料“Java多线程基础-01、数组概述”将带你入门Java的多线程世界，并结合数组这一基本数据结构进行讲解。 首先，我们需要理解什么是线程。线程是操作系统分配CPU时间的基本单位，一个进程可以有多个线程，它们...
Java多线程基础知识
gldzzznb的博客
04-10 3364
这是我再次学习多线程知识的一个总结，对于刚刚接触的学习者是比较友好易懂的，便于快速的理解和掌握。
Java多线程基础（一）
计蒙不吃鱼的博客
07-19 5890
文章分两份，第一份主要内容为1-4点 1.多线程的概念 2.Java程序运行原理 3.实现多线程的2种方式 4.2种方式的区别 5.线程同步（同步锁） 6.同步线程之间的通讯 1.多线程的概念 （1）并发和并行 并行：多个CPU实例或是多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过CUP调度算法，让用户看上去同时去执行，实际上从CPU操作层面并不是真正的同时。并发往往需要公共的资源，...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程（超详细！）
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java 多线程基础概念
明月燃雨
09-19 1万+
什么是进程？ 进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。操作系统在运行一个程序时，会为其创建一个进程。 什么是线程？ 线程与进程类似，但线程是一个比进程更小的执行单元，一个进程在执行过程中可以产生多个线程，线程是操作系统调度的最小单元。 在 Java 中，同一进程的多个线程共享该进程的堆和方法区资源，但每个线程都有自己独立的程序计数器、虚拟机栈和本地方法栈，所以系统在线程之间切换工作的负担要比进程小，因此线程也被叫做轻量级进程。 Java
java多线程基础五——isAlive()方法解释
Xmumu_的博客
02-15 3958
方法简单解释 该方法的功能就是判断当前的线程是否处于活动状态，那么什么是活动状态呢，活动状态就是线程已经启动且尚未终止，当线程正在运行或着准备开始运行的时候，就认为线程是“存活”的，并且以true和false的形式返回，下面举个小栗子： package MyThread; public class mythread extends Thread{ @Override public void run() { System.out.println("run="+this.isAlive());
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
Educoder头歌—Java多线程基础常用函数
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
03-23 7182
文章目录第1关：线程的状态与调度任务描述相关知识线程的状态与调度线程优先级编程要求题第2关：常用函数（一）任务描述相关知识2sleep()函数join()函数编程要求测试说明代码示例第3关：常用函数（二）任务描述相关知识yield 函数wait 函数线程常用函数总结编程要求测试说明代码示例 第1关：线程的状态与调度 任务描述 本关任务：学习本关知识完成选择题。 相关知识 为了完成本关你需要掌握： 1.线程的状态与调度； 2.线程执行的优先级。 线程的状态与调度 如果看懂下图，你对线程的了解就会更上一层楼。
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java 多线程基础笔记
最新发布
08-17
Java 多线程基础笔记
Java多线程基础-03、数组定义方式二、元素默认值规则.rar
11-20
总之，Java多线程基础是高效编程的关键，而理解数组定义和元素默认值规则则是构建安全、健壮的多线程程序的基础。通过合理运用多线程技术和掌握数组的内在特性，你可以编写出更加高性能、可扩展的Java应用程序。
一篇文章弄懂Java多线程基础和Java内存模型
12-21
Java多线程是并发编程的重要组成部分，理解和掌握其基础以及Java内存模型对于任何Java开发者来说都是必不可少的。本文将深入探讨这两个主题。 首先，我们来理解多线程的生命周期及其五种基本状态： 1. 新建状态...
Java级联调用方法的类设计
chenguangyun123的博客
11-13 759
      在Java方法设计时返回当前对象的引用(this)，可以实现级联调用的设计，如StringBuilder类中的append方法： public StringBuilder append(String str) { super.append(str); return this; }  使用时可以sb.append("a")....
JVM常量池和八种基本数据及字符串
chenguangyun123的博客
11-15 337
    常量池(constant_pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量和符号引用。运行时常量池是方法区的一部分。      在Class文件结构中，最头的4个字节用于存储魔数Magic Number，用于确定一个文件是否能被JVM接受，再接着4个字节用于存储版本号，前2个字节存储次版本号，后2个存储...
java.util.concurrent.atomic原子操作类包
chenguangyun123的博客
01-04 254
     这个包里面提供了一组原子变量类。其基本的特性就是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入，这只是一种逻辑上的理解。实际上是借助硬件的相关指令来实现的，不会阻塞线程(或者说只是在硬件级别上阻塞了)。可以...
Java泛型
chenguangyun123的博客
05-06 214
1、 泛型为JDK1.5 之后出现的新特性，类中的属性类型由外部定义，而且在声明类的时候应该采取下面形式： class 类名称 &lt; 泛型类型，泛型类型， ...&gt;{ } 如下类Point ： package com.chenzehe.test; public class Point&lt;T&gt; { // T为泛型类型，也可以由其它字母声明 ...
Java多线程基础与实战
本文旨在介绍Java多线程的基础知识，包括线程的实现方式、线程同步以及线程状态等核心概念。" 在Java中，线程是一个程序执行的最小单元，它代表了进程中的单一控制流。与进程相比，线程更加轻量级，因为它们共享...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值