Java线程

进程是一个正在执行的程序，是操作系统管理的。 执行过程，持有资源和线程。 多线程是一个进程中多个线程，轻量级的进程，线城是进程的组成。 线程是系统中最小的单元，一个进程=>多个线程，共享内存和资源。 有两种方法， 第一种，继承thread类，第二种实现runnable接口。 Thread:继承thread定义一个线程类，只要继承Thread类，他就是一个线程类。 第二种，实现Runnable接口。 重写run方法，run中就是代码要执行的代码。

几种解决线程同步的方法：

public class Bank { /** * @param args */ private int count = 0; //存钱 public void addMoney(int money){ count += money; System.out.println(System.currentTimeMillis()+"存进"+money); } //取钱 public void subMoney(int money){ if(count - money <0){ System.out.println("余额不足"); return; } count -= money; System.out.println(+System.currentTimeMillis()+"取出"+money); } //查询 public void lookmoney(){ System.out.println("账户余额" + count); } public static void main(String[] args) { // TODO Auto-generated method stub } }

第一种方法加锁

public class Bank2 { private int count = 0; //存钱 public synchronized void addMoney(int money){ count += money; System.out.println(System.currentTimeMillis()+"存进"+money); } //取钱 public synchronized void subMoney(int money){ if(count - money <0){ System.out.println("余额不足"); return; } count -= money; System.out.println(+System.currentTimeMillis()+"取出"+money); } //查询 public void lookmoney(){ System.out.println("账户余额" + count); } }

第二种：关键代码处加锁

同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

public class Bank3 { private int count = 0; //存钱 public void addMoney(int money){ synchronized(this){ count += money; } System.out.println(System.currentTimeMillis()+"存进"+money); } //取钱 public synchronized void subMoney(int money){ if(count - money <0){ System.out.println("余额不足"); return; } synchronized(this){ count -= money; } System.out.println(+System.currentTimeMillis()+"取出"+money); } //查询 public void lookmoney(){ System.out.println("账户余额" + count); } }

第三种：使用volatitle

a.volatile关键字为域变量的访问提供了一种免锁机制

b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新

c.因此每次使用该域就要重新计算，而不是使用寄存器中的值

d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量

public class Bank4 { private volatile int count = 0; public void addMoney(int Money){ if(count - Money <0){ System.out.println("余额不足"); return; } count +=Money; System.out.println(+System.currentTimeMillis() +"取出"+Money); } //取钱 public void subMoney(int money){ if(count - money <0){ System.out.println("余额不足"); return; } count -= money; System.out.println(+System.currentTimeMillis()+"取出"+money); } //查询 public void lookmoney(){ System.out.println("账户余额："+count); } }

第四种：

在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。

ReenreantLock类的常用方法有：

ReentrantLock() : 创建一个ReentrantLock实例

lock() : 获得锁

unlock() : 释放锁

注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用

public class Bank5 { private int count = 0; //需要声明这个锁 private Lock lock = new ReentrantLock(); //存钱 public void addMoney(int money){ lock.lock();//上锁 try{ count += money; System.out.println(System.currentTimeMillis()+"存进"+money); }finally{ lock.unlock();//解锁 } } public void subMoney(int money){ lock.lock(); if(count-money <0){ lock.lock(); try{ if(count-money<0){ System.out.println("余额不足"); return; } }finally{ lock.unlock(); } } } // 查询 public void lookMoney() { System.out.println("账户余额：" + count); } }

//线程启动

public class SynThreadTest { public static void main(String[] args) { final Bank4 bank = new Bank4(); //存钱线程 Thread tadd = new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub while(true){ try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } bank.addMoney(100); bank.lookmoney(); System.out.println("\n"); } } }); //取钱线程 Thread tsub =new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub while(true){ bank.subMoney(100); bank.lookmoney(); System.out.println("\n"); try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }); //线程启动。 tsub.start(); tadd.start(); } }