java 线程同步的方法_Java线程原理和5种同步方法

Java线程原理和5种同步方法

自己开发了一个股票智能分析软件，功能很强大，需要的点击下面的链接获取：

目录

1       Java线程原理和两种实现方式... 1

1.1      java线程原理和源码解析... 1

1.2      实现 Runnable 接口实现run方法... 2

1.3      继承Thread类重写run方法... 4

2       线程的状态变化... 5

3       线程函数... 6

4       Java线程同步方法... 7

4.1      Synchronized修饰方法或代码块... 7

4.2      Volatile修饰的变量... 7

4.3      使用重入锁实现线程同步... 7

1         Java线程原理和两种实现方式

1.1   java线程原理和源码解析

线程是为了实现并发运行，java线程实现有两种方式。一种是继承 Thread 类，另一种就是实现 Runnable 接口，实现Runnable接口的run函数。Thread类实际上也是实现了runnable接口，并且在Thread类中实现了Runnable接口的run函数，只是这个run函数是一个Override函数，继承Thread的类要么重写这个run函数，要入以入参的形式传入Runnable 接口实现类对象，也就是下面的target对象。总而言之，就是要实现run方法，要么重写，要么入参传入Runnable实现类对象。

Public classThread implementsRunnable {

……

@Override

public voidrun() {

if(target!= null) {

target.run();

}

}

……

Private Runnable target；

//构造函数1，需要重写run函数

publicThread(String name) {

init(null, null, name, 0);

}

//构造函数2,需要以入参传入的Runnable接口对象

public Thread(Runnable target,String name){

init(null,target,name,0);

}

//初始化函数

private void init(ThreadGroup g,Runnable target,String name,long stackSize){

...

this.target=target;

}

……

}

1.2   实现Runnable接口实现run方法

Runnable接口定义

interfaceRunnable {

/**

* When an object implementing

interface Runnable is used

* to create a thread, starting the

thread causes the object's

* run method to be called in that

separately executing

* thread.

*

* The general contract of the method

run is that it may

* take any action whatsoever.

*

* @seejava.lang.Thread#run()

*/public abstract voidrun();

}

classMyThread implementsRunnable{ //实现Runnable接口，作为线程的实现类privateString name;       //表示线程的名称publicMyThread(String name){

this.name= name ;      //通过构造方法配置name属性}

public voidrun(){  //覆写run()方法，作为线程的操作主体for(inti=0;i<10;i++){

System.out.println(name+ "运行，i = "+ i) ;

}

}

public static voidmain(String args[]){

MyThread mt1 = newMyThread("线程A ") ;    //实例化对象MyThread mt2 = newMyThread("线程B ") ;    //实例化对象Thread t1 = newThread(mt1) ;       //实例化Thread类对象Thread t2 = newThread(mt2) ;       //实例化Thread类对象t1.start() ;    //启动多线程t2.start() ;    //启动多线程}

};

运行结果为：

线程B 运行，i = 0

线程B 运行，i = 1

线程B 运行，i = 2

线程B 运行，i = 3

线程B 运行，i = 4

线程B 运行，i = 5

线程B 运行，i = 6

线程B 运行，i = 7

线程B 运行，i = 8

线程B 运行，i = 9

线程A 运行，i = 0

线程A 运行，i = 1

线程A 运行，i = 2

线程A 运行，i = 3

线程A 运行，i = 4

线程A 运行，i = 5

线程A 运行，i = 6

线程A 运行，i = 7

线程A 运行，i = 8

线程A 运行，i = 9

1.3   继承Thread类重写run方法

class MyThread extends Thread{  // 继承Thread类，作为线程的实现类

private String name ;       // 表示线程的名称

public MyThread(String name){

this.name = name ;      // 通过构造方法配置name属性

}

public void run(){  // 覆写run()方法，作为线程 的操作主体

for(int i=0;i<10;i++){

System.out.println(name + "运行，i = " + i) ;

}

}

};

public class ThreadDemo02{

public static void main(String args[]){

MyThread mt1 = new MyThread("线程A ") ;    // 实例化对象

MyThread mt2 = new MyThread("线程B ") ;    // 实例化对象

mt1.start() ;   // 调用线程主体

mt2.start() ;   // 调用线程主体

}

};

线程A 运行，i = 0

线程B 运行，i = 0

线程B 运行，i = 1

线程B 运行，i = 2

线程B 运行，i = 3

线程B 运行，i = 4

线程B 运行，i = 5

线程B 运行，i = 6

线程B 运行，i = 7

线程B 运行，i = 8

线程B 运行，i = 9

线程A 运行，i = 1

线程A 运行，i = 2

线程A 运行，i = 3

线程A 运行，i = 4

线程A 运行，i = 5

线程A 运行，i = 6

线程A 运行，i = 7

线程A 运行，i = 8

线程A 运行，i = 9

2         线程的状态变化

要想实现多线程，必须在主线程中创建新的线程对象。任何线程一般具有5种状态，即创建，就绪，运行，阻塞，终止。下面分别介绍一下这几种状态：

创建状态

在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时它已经有了相应的内存空间和其他资源，但还处于不可运行状态。新建一个线程对象可采用Thread 类的构造方法来实现，例如 “Thread thread=new Thread()”。

就绪状态

新建线程对象后，调用该线程的 start() 方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待 CPU 服务，这表明它已经具备了运行条件。

运行状态

当就绪状态被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的 run() 方法。run() 方法定义该线程的操作和功能。

阻塞状态

一个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入/输出操作，会让 CPU 暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(),suspend(),wait() 等方法，线程都将进入阻塞状态，发生阻塞时线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。

死亡状态

线程调用 stop() 方法时或 run() 方法执行结束后，即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。

3         线程函数

(1)独占CPU启动线程

join() 方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。

(2)线程休眠

Thread.sleep(500) 即可实现休眠500ms

(3)线程优先级

线程将根据其优先级的大小来决定哪个线程会先运行，但是需要注意并非优先级越高就一定会先执行，哪个线程先执行将由 CPU 的调度决定。

t1.setPriority(Thread.MIN_PRIORITY) ;   // 优先级最低

t2.setPriority(Thread.MAX_PRIORITY) ;   // 优先级最高

t3.setPriority(Thread.NORM_PRIORITY) ;  // 优先级最中等

(4)中断线程

当一个线程运行时，另外一个线程可以直接通过interrupt()方法中断其运行状态。

(5)线程礼让

也可以使用 yield() 方法将一个线程的占用资源暂时让给其他线程执行。

4         Java线程同步方法

4.1   Synchronized修饰方法或代码块

java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

public synchronized void save(){} 或者

synchronized (this)

{ account += money;}

4.2   Volatile修饰的变量

如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。多处理器下，其他处理器发现自己缓存行对应的内存地址被修改，就会重新读取数据。在需要同步操作的变量前加上volatile

private volatile int account = 100;

4.3   使用重入锁实现线程同步

JavaSE5.0中新增了一个java.util.concurrent包来支持同步。 ReentrantLock类是可重入、互斥、实现了Lock接口的锁。

ReentrantLock() : 创建一个ReentrantLock实例

lock() : 获得锁

unlock()

: 释放锁

只给出要修改的代码，其余代码与上同

class Bank {

private int account = 100;

//需要声明这个锁

private Lock lock = new ReentrantLock();

public int getAccount() {

return account;

}

//这里不再需要synchronized

public void save(int money) {

lock.lock();

try{

account += money;

}finally{

lock.unlock();

}

}

｝

4.4

原子变量实现线程同步

原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作

即-这几种行为要么同时完成，要么都不完成。

在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类。

其中AtomicInteger 表可以用原子方式更新int的值AtomicInteger类常用方法：

AtomicInteger(int initialValue) : 创建具有给定初始值的新的AtomicInteger，addAddGet(int

dalta) : 以原子方式将给定值与当前值相加。get() : 获取当前值。

代码实例

class Bank {

private AtomicIntegeraccount

= new AtomicInteger(100);

public AtomicInteger getAccount() {

return account;

}

public void save(int money) {

account.addAndGet(money);

}

}

4.5

阻塞队列实现线程同步

(1)LinkedBlockingQueue内部实现是单链表结构。LinkedBlockingQueue插入和读取是有两把ReentrantLock锁的，LinkedBlockingQueue 是插入和拿取数据都是阻塞执行的。内部采用原子变量AtomicInteger统计个数。

(2)ArrayBlockingQueue，内部实现是数组。插入和读取用的是同一把锁，内部采用int变量统计数量。

LinkedBlockingQueue类常用方法

LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue

put(E e) : 在队尾添加一个元素，如果队列满则阻塞

size() : 返回队列中的元素个数

take() : 移除并返回队头元素，如果队列空则阻塞

BlockingQueue定义了阻塞队列的常用方法，尤其是三种添加元素的方法，我们要多加注意，当队列满时：

add()方法会抛出异常

offer()方法返回false

put()方法会阻塞