java多线程

java多线程

什么是线程,线程是现代操作系统调度的最小单元是线程,也叫轻量级进程,在一个进程里可创建多个线程,这些线程都拥有各自的计数器、堆栈和局部变量等属性,并且能够访问共享的内存变量。处理器在这些线程上高速切换,让使用者感觉到这些线程在同时执行。
1、线程的状态
Java线程在运行的生命周期中可能处于6种不同的状态,在给定的一个时刻,线程只能处于其中的一个状态:

NEW: 新建状态,线程对象已经创建,但尚未启动
RUNNABLE:就绪状态,可运行状态,调用了线程的start方法,已经在java虚拟机中执行,等待获取操作系统资源如CPU,操作系统调度运行。
BLOCKED:堵塞状态。线程等待锁的状态,等待获取锁进入同步块/方法或调用wait后重新进入需要竞争锁
WAITING:等待状态。等待另一个线程以执行特定的操作。调用以下方法进入等待状态。 Object.wait(), Thread.join(),LockSupport.park
TIMED_WAITING: 线程等待一段时间。调用带参数的Thread.sleep, objct.wait,Thread.join,LockSupport.parkNanos,LockSupport.parkUntil
TERMINATED:进程结束状态。

2、线程的创建四种方式
1、继承Thread类创建线程
2、实现Runnable接口创建线程
3、使用Callable和Future创建线程
4、使用线程池例如用Executor框架
3、java 并发编程的三大特点
原子性:个操作不能被打断,要么全部执行完毕,要么不执行。在这点上有点类似于事务操作,要么全部执行成功,要么回退到执行该操作之前的状态。
可见性:一个线程对共享变量做了修改之后,其他的线程立即能够看到(感知到)该变量这种修改(变化)。
有序性:对于一个线程的代码而言,我们总是以为代码的执行是从前往后的,依次执行的。这么说不能说完全不对,在单线程程序里,确实会这样执行;但是在多线程并发时,程序的执行就有可能出现乱序。用一句话可以总结为:在本线程内观察,操作都是有序的;如果在一个线程中观察另外一个线程,所有的操作都是无序的。前半句是指“线程内表现为串行语义(WithIn Thread As-if-Serial Semantics)”,后半句是指“指令重排”现象和“工作内存和主内存同步延迟”现象。

我们看看下面这段代码:

public class TestMain {
	private  int i = 0;
	public static void main(String[] args) {
		TestMain aa = new TestMain();
		aa.go();
	}
	void go(){
		for(int j = 0;j<10;j++){
			new Thread(new Runnable(){
				@Override
				public void run() {
					for(int k = 0;k<100000;k++){
						i++;
						System.out.println(i);
					}	
				}			
			}).start();
		}
	}
}

都知道,当go函数在执行的时候,创建的10个线程,每个线程都需要加100000次,由于没有满足并发的三大特点。这里计算出来的结果就会存在问题。
原子性:这里的i++,看上去只有一步操作,实际上需要取出来i的值,然后加上1,在写进去。根本就不能满足。
当我们使用synchronized之后。这个关键字能够保证原子性,和可见性。也就是说每个时刻只有一个线程能够进入到这个方法中,必须一个线程执行完这个片段之后,其它的线程才能够调用。



public class TestMain {
	int i = 1;
	public static void main(String[] args) {
		TestMain aa = new TestMain();
		aa.go();
	}
	
	void go(){
		for(int j = 0;j<10;j++){
			new Thread(new Runnable(){
				@Override
				public void run() {
					for(int k = 0;k<100000;k++){
						synchronized(TestMain.class){
							i++;
							System.out.println(i);
						}
					}
				}			
			}).start();
		}
	}
}

当加上同步锁之后,得到正确的结果。
当线程获取锁时,JVM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须从主内存中读取共享变量。当线程执行到synchronized的时候,获取锁。由于锁的原子性,必须把同步块中的内容执行完成之后,才会释放锁。当线程释放锁时,JVM会把该线程对应的本地内存中的共享变量刷新到主内存中.
同理:使用 重入锁也能实现。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestMain {
	private volatile int i = 1;
	private Lock lock = new ReentrantLock();
	public static void main(String[] args) {
		TestMain aa = new TestMain();
		aa.go();
	}
	void go(){
		for(int j = 0;j<10;j++){
			new Thread(new Runnable(){
				@Override
				public void run() {
					for(int k = 0;k<100000;k++){
							lock.lock();
							try{
							i++;
							System.out.println(i);
							}finally{
								lock.unlock();
							}	
					}	
				}			
			}).start();
		}
	}
}

看一个单利模式



public class TestMain {
	private TestMain(){}
	private volatile TestMain instance;
	public TestMain getInstance(){
		if(instance == null){
			synchronized(TestMain.class){
				if(instance == null){
					instance = new TestMain();
				}
			}
		}
		return instance;
	}
}

这是一个常见的支持多线程的单利模式,使用了双重检查。和volatile。volatile的作用是让线程修改了这个变量之后,其它线程能够立马知道。volatile的本意是:不稳定的,当线程使用到这个数据的时候,都会从内存中读取。双重检查也在一定程度上提高了程序运行效率,当在锁外部从内存中读取到instance已经被初始化。这时候,就会不在执行加锁的操作。直接返回instance。当发现instance没有被初始化化,在执行加锁操作之前,其它线程已经将instance初始化了。这时候,同步锁的机制就会从内存中去读取instance。判断一下。直接返回。双重锁机制在多线程单利是很重要的。它保证了高效率的有且仅有一次的初始化。

你可能感兴趣的:(java,java,多线程,单例,双重锁)