多线程

进程与程序的区别
程序是一组指令的集合，它是静态的实体，没有执行的含义。而进程是一个动态的实体，有自己的生命周期。一般说来，一个进程肯定与一个程序相对应，并且只有一个，但是一个程序可以有多个进程，或者一个进程都没有。除此之外，进程还有并发性和交往性。简单地说，进程是程序的一部分，程序运行的时候会产生进程。

JAVA中如何实现多线程（重点！！）

通过继承Thread类实现多线程

Ø 在Java中负责线程的这个功能的是Java.lang.Thread 这个类

Ø 可以通过创建 Thread 的实例来创建新的线程。

Ø 每个线程都是通过某个特定Thread对象所对应的方法run( )来完成其操作的，方法run( )称为线程体。

Ø 通过调用Thead类的start()方法来启动一个线程。

public class TestThread extends Thread {

public void run() {

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

System.out.println(this.getName()+":"+i);

}

public static void main(String[] args) {

TestThread thread1 = new TestThread();

thread1.start();

TestThread thread2 = new TestThread();

thread2.start();

}

这种方式的缺点：那就是如果我们的类已经从一个类继承（如小程序必须继承自 Applet 类），则无法再继承 Thread类

通过Runnable接口实现多线程

优点：可以同时实现继承。实现Runnable接口方式要通用一些。

public class TestThread2 implements Runnable {

int threadId;

public TestThread2(int id) {

super();

this.threadId=id;

}

public static void main(String[] args) {

Thread thread1 = new Thread(new TestThread2(1));

thread1.start();

Thread thread2 = new Thread(new TestThread2(2));

thread2.start();

}

public void run() {

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

System.out.println(this.threadId+":"+i);

}

线程状态和sleep/yield/join/stop/destroy方法

新生状态：

用new关键字和Thread类或其子类建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态（runnable）

就绪状态：

处于就绪状态的线程已经具备了运行条件，但还没有分配到CPU，处于线程就绪队列，等待系统为其分配CPU。等待状态并不是执行状态，当系统选定一个等待执行的Thread对象后，它就会从等待执行状态进入执行状态，系统挑选的动作称之为“cpu调度”。一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。

运行状态：

在运行状态的线程执行自己的run方法中代码，直到调用其他方法而终止、或等待某资源而阻塞或完成任务而死亡。如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。

死亡状态：

死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有两个。一个是正常运行的线程完成了它的全部工作；另一个是线程被强制性地终止，如通过执行stop或destroy方法来终止一个线程[雨林木风1]

Method stop() & destroy() in the class Thread is deprecated。

当一个线程进入死亡状态以后，就不能再回到其它状态了。让一个Thread对象重新执行一次的唯一方法，就是重新产生一个Thread对象。

终止线程的典型方法（重要！！！）

public class TestThreadCiycle implements Runnable {

String name;

boolean live = true;

public TestThreadCiycle(String name) {

super();

this.name = name;

}

public void run() {

int i=0;

while(live){

System.out.println(name+(i++));

}

public void terminate(){

live = false;

}

public static void main(String[] args) {

TestThreadCiycle ttc = new TestThreadCiycle("线程A:");

Thread t1 = new Thread(ttc); //新生状态

t1.start(); //就绪状态

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

System.out.println(i);

}

ttc.terminate();

System.out.println("ttc stop!");

}

阻塞状态：

处于运行状态的线程在某些情况下，如执行了sleep（睡眠）方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入阻塞状态。

n 在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续运行。

n 有三种方法可以暂停Threads执行：

1. sleep方法：Sleep时别的线程也不可以访问锁定对象。

2. yield方法: 让出CPU的使用权，从运行态直接进入就绪态。让CPU重新挑选哪一个线程进入运行状态。

3. join方法: 当某个线程等待另一个线程执行结束后，才继续执行时，使用join方法。使调用该方法的线程在此之前执行完毕，也就是等待调用该方法的线程执行完毕后再往下继续执行

public class TestThreadState {

public static void main(String[] args) {

//使用继承方式实现多线程

// StateThread thread1 = new StateThread();

// thread1.start();

// StateThread thread2 = new StateThread();

// thread2.start();

System.out.println("爸爸和儿子买烟故事");

Thread father = new Thread(new FatherThread());

father.start();

}

class StateThread extends Thread {

public void run(){

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

System.out.println(this.getName()+":"+i);

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

Thread.yield();

}

class FatherThread implements Runnable {

public void run() {

System.out.println("爸爸想抽烟，发现烟抽完了");

System.out.println("爸爸让儿子去买包红塔山");

Thread son = new Thread(new SonThread());

son.start();

System.out.println("爸爸等儿子买烟回来");

try {

son.join();

} catch (InterruptedException e) {

e.printStackTrace();

System.out.println("爸爸出门去找儿子跑哪去了");

System.exit(1);//结束JVM。如果是0则表示正常结束；如果是非0则表示非正常结束

}

System.out.println("爸爸高兴的接过烟开始抽，并把零钱给了儿子");

}

class SonThread implements Runnable {

public void run() {

System.out.println("儿子出门去买烟");

System.out.println("儿子买烟需要10分钟");

try {

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

System.out.println("第" + i + "分钟");

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("儿子买烟回来了");

}

线程基本信息和优先级别

方法	功能
isAlive()	判断线程是否还“活”着，即线程是否还未终止。
getPriority()	获得线程的优先级数值
setPriority()	设置线程的优先级数值
setName()	给线程一个名字
getName()	取得线程的名字
currentThread()	取得当前正在运行的线程对象，也就是取得自己本身

public class ThreadTest3 {

public static void main(String[] argc) throws Exception {

Runnable r = new Thread6();

Thread t = new Thread(r, "Name test");

t.start();

System.out.println("name is: " + t.getName());

Thread.currentThread().sleep(5000);

System.out.println(t.isAlive());

System.out.println("over!");

}

class Thread6 implements Runnable {

public void run() {

for (int i = 0; i < 100; i++)

System.out.println(i);

}

n Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程。线程调度器按照线程的优先级决定应调度哪个线程来执行。

n 线程的优先级用数字表示，范围从1到10

一个线程的缺省优先级是5

q Thread.MIN_PRIORITY= 1

q Thread.MAX_PRIORITY= 10

q Thread.NORM_PRIORITY= 5

n 使用下述线方法获得或设置线程对象的优先级。

q intgetPriority();

voidsetPriority(int newPriority);

注意：优先级低只是意味着获得调度的概率低。并不是绝对先调用优先级高后调用优先级低的线程。

public class ThreadTest4 {

public static void main(String[] args) {

Thread t1 = new Thread(new Thread7(), "t1");

Thread t2 = new Thread(new Thread7(), "t2");

t1.setPriority(1);

t2.setPriority(10);

t1.start();

t2.start();

}

class Thread7 extends Thread {

public void run() {

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

System.out.println(Thread.currentThread().getName() + ": " + i);

// yield();

}

线程同步和死锁问题(B++)

问题：

/**

* 测试同步问题

* @author Administrator

public class TestSync {

public static void main(String[] args) {

Account a1 = new Account(100,"高");

Drawing draw1 = new Drawing(80,a1);

Drawing draw2 = new Drawing(80,a1);

draw1.start(); //你取钱

draw2.start(); //你老婆取钱

}

* 简单表示银行账户

class Account {

int money;

String aname;

public Account(int money, String aname) {

super();

this.money = money;

this.aname = aname;

}

/**

* 模拟提款操作

* @author Administrator

class Drawing extends Thread{

int drawingNum; //取多少钱

Account account; //要取钱的账户

int expenseTotal; //总共取的钱数

public Drawing(int drawingNum,Account account) {

super();

this.drawingNum = drawingNum;

this.account = account;

}

@Override

public void run() {

if(account.money-drawingNum<0){

return;

}

try {

Thread.sleep(1000); //判断完后阻塞。其他线程开始运行。

} catch (InterruptedException e) {

e.printStackTrace();

}

account.money-=drawingNum;

expenseTotal+=drawingNum;

System.out.println(this.getName()+"--账户余额："+account.money);

System.out.println(this.getName()+"--总共取了："+expenseTotal);

}

结果：

Thread-0--账户余额：20

Thread-1--账户余额：-60

Thread-0--总共取了：80

Thread-1--总共取了：80

由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。

　　由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized块

　1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明synchronized 方法。如：
　　publicsynchronized [雨林木风2] void accessVal(int newVal);

synchronized方法控制对类成员变量的访问：每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁方能执行[雨林木风3]，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。

synchronized 方法的缺陷：若将一个大的方法声明为synchronized将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是synchronized 块。

2.synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：
　　synchronized(syncObject)
　　{
　　//允许访问控制的代码
　　}

/**

* 测试同步问题

* @author Administrator

public class TestSync {

public static void main(String[] args) {

Account a1 = new Account(100,"高");

Drawing draw1 = new Drawing(80,a1);

Drawing draw2 = new Drawing(80,a1);

draw1.start(); //你取钱

draw2.start(); //你老婆取钱

}

* 简单表示银行账户

class Account {

int money;

String aname;

public Account(int money, String aname) {

super();

this.money = money;

this.aname = aname;

}

/**

* 模拟提款操作

* @author Administrator

class Drawing extends Thread{

int drawingNum; //取多少钱

Account account; //要取钱的账户

int expenseTotal; //总共取的钱数

public Drawing(int drawingNum,Account account) {

super();

this.drawingNum = drawingNum;

this.account = account;

}

@Override

public void run() {

draw();

}

void draw(){

synchronized (account) [雨林木风4]{

if(account.money-drawingNum<0){

return;

}

try {

Thread.sleep(1000); //判断完后阻塞。其他线程开始运行。

} catch (InterruptedException e) {

e.printStackTrace();

}

account.money-=drawingNum;

expenseTotal+=drawingNum;

}

System.out.println(this.getName()+"--账户余额："+account.money);

System.out.println(this.getName()+"--总共取了："+expenseTotal);

}

上面这种方式叫做：互斥锁原理。利用互斥锁解决临界资源问题。

死锁及解决方案：

class Lipstick{

}

class Mirror{

}

class Makeup extends Thread {

int flag;

String girl;

static Lipstick lipstick=new Lipstick();

static Mirror mirror= new Mirror();

[雨林木风5]

@Override

public void run() {

// TODO Auto-generated method stub

doMakeup();

}

void doMakeup(){

if(flag==0){

synchronized (lipstick) {

System.out.println(girl+"拿着口红！");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

synchronized (mirror) {

System.out.println(girl+"拿着镜子！");

}

else{

synchronized (mirror) {

System.out.println(girl+"拿着镜子！");

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

synchronized (lipstick) {

System.out.println(girl+"拿着口红！");

}

public class TestDeadLock {

public static void main(String[] args) {

Makeup m1 = new Makeup(); m1.girl="大丫"; m1.flag=0;

Makeup m2 = new Makeup(); m2.girl="小丫"; m2.flag=1;

m1.start();

m2.start();

}

如何解决死锁问题：

1. 往往是程序逻辑的问题。需要修改程序逻辑。

2. 尽量不要同时持有两个对象锁。如修改成如下：

void doMakeup(){

if(flag==0){

synchronized (lipstick) {

System.out.println(girl+"拿着口红！");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

synchronized (mirror) {

System.out.println(girl+"拿着镜子！");

}

[雨林木风6] }

else{

synchronized (mirror) {

System.out.println(girl+"拿着镜子！");

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

synchronized (lipstick) {

System.out.println(girl+"拿着口红！");

}

解决多线程问题的另外一种思路是同步。同步是另外一种解决问题的思路，结合前面卫生间的示例，互斥方式解决多线程的原理是，当一个人进入到卫生间内部时，别的人只能在外部时刻等待，这样就相当于别的人虽然没有事情做，但是还是要占用别的人的时间，浪费系统的执行资源。而同步解决问题的原理是，如果一个人进入到卫生间内部时，则别的人可以去睡觉，不占用系统资源，而当这个人从卫生间出来以后，把这个睡觉的人叫醒[雨林木风7]，则它就可以使用临界资源了。所以使用同步的思路解决多线程问题更加有效，更加节约系统的资源。

在常见的多线程问题解决中，同步问题的典型示例是“生产者-消费者”模型，也就是生产者线程只负责生产，消费者线程只负责消费，在消费者发现无内容可消费时则睡觉

同步解决问题的另一种典型方式：生产者/消费者[雨林木风8]模式:

在常见的多线程问题解决中，同步问题的典型示例是“生产者-消费者”模型，也就是生产者线程只负责生产，消费者线程只负责消费，在消费者发现无内容可消费时则睡觉。下面举一个例子。

public class TestProduce {

public static void main(String[] args) {

SyncStack sStack = new SyncStack();

Shengchan sc = new Shengchan(sStack);

Xiaofei xf = new Xiaofei(sStack);

sc.start();

xf.start();

}

class Mantou {

int id;

Mantou(int id){

this.id=id;

}

class SyncStack{

int index=0;

Mantou[] ms = new Mantou[10];

public synchronized void push(Mantou m){

while(index==ms.length){

try {

this.wait();

//wait后，线程会将持有的锁释放。sleep是即使睡着也持有互斥锁。

} catch (InterruptedException e) {

e.printStackTrace();

}

this.notify(); //唤醒在当前对象等待池中等待的第一个线程。notifyAll叫醒所有在当前对象等待池中等待的所有线程。

//如果不唤醒的话。以后这两个线程都会进入等待线程，没有人唤醒。

ms[index]=m;

index++;

}

public synchronized Mantou pop(){

while(index==0){

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

this.notify();

index--;

return ms[index];

}

class Shengchan extends Thread{

SyncStack ss = null;

public Shengchan(SyncStack ss) {

// TODO Auto-generated constructor stub

this.ss=ss;

}

@Override

public void run() {

// TODO Auto-generated method stub

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

System.out.println("造馒头："+i);

Mantou m = new Mantou(i);

ss.push(m);

}

class Xiaofei extends Thread{

SyncStack ss = null;

public Xiaofei(SyncStack ss) {

// TODO Auto-generated constructor stub

this.ss=ss;

}

@Override

public void run() {

// TODO Auto-generated method stub

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

Mantou m = ss.pop();

System.out.println("吃馒头："+i);

}

线程回顾总结：

New:创建好线程对象,但没有启动的时候.

一个线程调用start()之后不一定会马上启动,此时进入就绪状态,等待得到资源.

就绪线程序通过Scheduler(调度程序)去确定是否运行.

Runing---dead:运行结束(非双向,为单向箭头)

Runing---就绪:暂停(除了没有CPU,具备运行的所有条件)

Runing-otherwise(阻塞):因程序原因:调用sleep或join之后,线程被阻塞.这时不具备运行的条件,此时线程进入阻塞池.sleep或join条件解除之后直接进入Runnable不进入running.

Lockpool:锁池状态。每个对象都有自己的锁池，锁池里放置了想获得对象锁的线程。

等待状态(wait pool)：比如一个线程调用了某个对象的wait()方法，就进入了该对象的wait pool, 正在等待其它线程调用这个对象的notify()或者notifyAll()（这两个方法同样是继承自Object类）方法来唤醒它；

任务调度(补充内容，了解即可！)

通过java timer timetask：(spring的任务调度就是通过他们来实现的)

课外知识：使用开源框架quartz实现任务调度

在这种实现方式中，Timer类实现的是类似闹钟的功能，也就是定时或者每隔一定时间触发一次线程。其实，Timer类本身实现的就是一个线程，只是这个线程是用来实现调用其它线程的。而TimerTask类是一个抽象类，该类实现了Runnable接口，所以按照前面的介绍，该类具备多线程的能力。

在这种实现方式中，通过继承TimerTask使该类获得多线程的能力，将需要多线程执行的代码书写在run方法内部，然后通过Timer类启动线程的执行。

在实际使用时，一个Timer可以启动任意多个TimerTask实现的线程，但是多个线程之间会存在阻塞。所以如果多个线程之间如果需要完全独立运行的话，最好还是一个Timer启动一个TimerTask实现。

java.util.Timer的使用：

public class TestTimer {

public static void main(String[] args) {

Timer t1 = new Timer();

MyTask task1 = new MyTask();

// t1.schedule(task1,3000); //3秒后执行

t1.schedule(task1,5000,1000); //5秒以后每隔1秒执行一次！

// GregorianCalendar calendar1 = new GregorianCalendar(2010,0,5,14,36,57); //注意月份是0-11

// t1.schedule(task1,calendar1.getTime()); //指定时间定时执行

}

class MyTask extends TimerTask{

public void run() {

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

System.out.println("任务1:"+i);

}

不推荐使用这两个方法。前者会产生异常，后者是强制终止，不会释放锁。

同步的方法必须获得对象的锁才能运行。普通方法不获得锁也可以运行。

跟synchronize(this)意思差不多。

需要拿到account对象的锁，才能运行。

注意是static。这样才能使两个线程得到的是同一个数据

不放在上面同步块里面。不同时持有两个锁。

就是wait,notify的应用。

生产者和消费者共享了SyncStack对象。一个从里面拿东西，一个从里面消费东西。

CCCC知识点

iteye_1261

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程

......................................................................................................................... 0基本概念. 1程序...................................................................
复制链接

扫一扫