......................................................................................................................... 0基本概念. 1
通过继承Thread类实现多线程.................................................................................. 2
基本概念
程序
Java源程序和字节码文件被称为“程序” (Program)，是一个静态的概念。
进程
执行中的程序叫做进程(Process)，是一个动态的概念。
q 进程是程序的一次动态执行过程, 占用特定的地址空间.
q 每个进程由3部分组成：cpu,data,code。每个进程都是独立的，保有自己的cpu时间，代码和数据，即便用同一份程序产生好几个进程，它们之间还是拥有自己的这3样东西。 缺点：内存的浪费，cpu的负担
q 多任务(Multitasking)操作系统à将CPU时间动态地划分给每个进程，操作系统同时执行多个进程，每个进程独立运行。以进程的观点来看，它会以为自己独占Cpu的使用权
q 进程的查看
q Windows系统: Ctrl+Alt+Del
q Unix系统: ps or top
线程
q 线程是进程中一个“单一的连续控制流程” (a single sequential flow ofcontrol)/执行路径。线程也可以达到同一份程序产生好几个进程的效果，但是不同的线程之间可以有某种程度上的资源共享，所以线程又被称为轻量级进程(lightweightprocess)。
q Threads run at the same time, independently of one another
q 一个进程可拥有多个并行的(concurrent)线程
q 一个进程中的线程共享相同的内存单元/内存地址空间à可以访问相同的变量和对象，而且它们从同一堆中分配对象à通信、数据交换、同步操作
q 由于线程间的通信是在同一地址空间上进行的，所以不需要额外的通信机制，这就使得通信更简便而且信息传递的速度也更快。
线程和进程的区别
§ 每个进程都有独立的代码和数据空间(进程上下文)，进程间的切换会有较大的开销。
§ 线程可以看成时轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换的开销小。
§ 线程和进程最根本的区别在于：进程作为资源分配的单位，线程是调度和执行的单位
§ 多进程: 在操作系统中能同时运行多个任务(程序)
§ 多线程: 在同一应用程序中有多个顺序流同时执行
§ 线程是进程的一部分，所以线程有的时候被称为是轻权进程或者轻量级进程。
§ 一个没有线程的进程是可以被看作单线程的，如果一个进程内拥有多个进程，进程的执行过程不是一条线（线程）的，而是多条线（线程）共同完成的。
§ 系统在运行的时候会为每个进程分配不同的内存区域，但是不会为线程分配内存（线程所使用的资源是它所属的进程的资源），线程组只能共享资源。那就是说，出了CPU之外（线程在运行的时候要占用CPU资源），计算机内部的软硬件资源的分配与线程无关，线程只能共享它所属进程的资源。
进程与程序的区别
程序是一组指令的集合，它是静态的实体，没有执行的含义。而进程是一个动态的实体，有自己的生命周期。一般说来，一个进程肯定与一个程序相对应，并且只有一个，但是一个程序可以有多个进程，或者一个进程都没有。除此之外，进程还有并发性和交往性。简单地说，进程是程序的一部分，程序运行的时候会产生进程。
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 方法。如：
public synchronized [雨林木风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(); @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知识点
扫一扫
903
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
