java 键盘 线程_线程（java课堂笔记）

1.两种方式的差异

2.线程的生命周期

3.线程控制(线程的方法)

4.线程同步

5.线程同步锁

一、 两种方式的差异

A extends Thread ：简单

不能再继承其他类了(Java单继承)同份资源不共享

B implements Runnable:( 推荐) )多个线程共享一个目标资源，适合多线程处理同一份资源。

该类还可以继承其他类，也可以实现其他接口。

二、 线程的生命周期

新建：当程序使用new创建一个线程后，该线程处于新建状态，此时他和其他java对象一样，仅仅由Java虚拟机为其分配内存并初始化成员变量值。【 Thread r = new Thread()】

就绪：当线程对象调用start()方法后，该线程处于就绪状态，线程计入线程队列排队，此时该状态线程并未开始执行，它仅表示可以运行了。至于该线程何时运行，取决于JVM线程调度器的调度。【 r.start() 】

运行：若处于就绪状态的线程获得了CPU，开始执行run()线程执行体，该线程处于执行状态。

阻塞：线程运行过程中需要被中断，目的是是其他的线程获得执行的机会。该状态就会进入阻塞状态。

注意：阻塞状态不能直接转成运行状态，阻塞状态只能重新进入就绪状态。

死亡：run()执行完成，线程正常结束;

线程抛出未捕获的Exception或Error;

调用线程的stop()。(易导致死锁，不推荐)

注意：

主线程结束后，其他线程不受其影响，不会随之结束;一旦子线程启动起来后，就拥有和主线程相等地位，不受主线程影响。

例子：

class MyThread implementsRunnable {public voidrun() {for (int i = 0; i < 200;i++) {

System.out.println(i);

}

}

}public classMyThreadDemo {public static voidmain(String[] args) {for (int i = 0; i < 10;i++) {if(i == 5){

MyThread t= newMyThread();newThread(t).start();

}

System.out.println("main" +i);

}

}

}

测试线程是否活着，可用线程对象的isAlive()方法。当线程处于就绪，运行，阻塞状态返回true。

当线程处于新建和死亡状态，返回false。

已死亡的线程是不可能通过start()方法唤醒线程的。

否则引发IllegalThreadStateException异常；

public classDieThreadDemo {public static voidmain(String[]args) {

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

Thread mainThread=Thread.currentThread();//获得当前线程(Main线程)

System.out.println(mainThread.getName()+ "--" +i);

System.out.println("------>"+mainThread.isAlive());if (i == 10) {

dt.start();

}

}if (!dt.isAlive()) {

dt.start();

}

}

}class DeadThread extendsThread {public voidrun() {for (int i = 0; i < 50; i++) {

System.out.println(getName()+"--" +i);

}

}

}

三、线程控制

Join()方法：等待该线程终止。

join 方法：调用join方法的线程对象强制运行，该线程强制运行期间，其他线程无法运行，必须等到该线程结束后其他线程才可以运行。

有人也把这种方式成为联合线程

join方法的重载方法:

join(long millis):

join(long millis,int nanos):

通常很少使用第三个方法:

程序无须精确到一纳秒;

计算机硬件和操作系统也无法精确到一纳秒;

public classJoinDemo {public static void main(String[]args) throwsException {

Thread join= new Thread(newJoin(),"Join线程");

join.start();int i = 0;while(i < 500){if(i == 100){

join.join();

}

System.out.println("Main -- > "+ i ++);

}

}

}class Join implementsRunnable {public voidrun() {int i = 0;while(i< 200){

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

}

}

}

setDaemon()方法

后台线程：处于后台运行，任务是为其他线程提供服务。也称为“守护线程”或“精灵线程”。

JVM的垃圾回收就是典型的后台线程。

特点：若所有的前台线程都死亡，后台线程自动死亡。

设置后台线程：Thread对象setDaemon(true);

setDaemon(true)必须在start()调用前。

否则出现IllegalThreadStateException异常；

前台线程创建的线程默认是前台线程;

判断是否是后台线程：使用Thread对象的isDaemon()方法；

并且当且仅当创建线程是后台线程时，新线程才是后台线程。

class Daemon extendsThread {public voidrun() {for (int i = 0; i < 10000; i++) {

System.out.println(getName()+"-" +i);

}

}

}public classDaemonDemo {public static voidmain(String[]args) {

Daemon d= newDaemon();

d.setDaemon(true);//把 d 线程设置成后台线程

d.start();for (int i = 0; i < 5; i++) {

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

}

}

}

Sleep()

线程休眠:

让执行的线程暂停一段时间，进入阻塞状态。

sleep(long milllis) throws InterruptedException：毫秒

sleep(long millis,int nanos) throws InterruptedException:毫秒，纳秒

调用sleep()后，在指定时间段之内，该线程不会获得执行的机会。

public classSleepDemo {public static voidmain(String[]args) {for (int i = 10; i > 0; i--) {

System.out.println("还剩" +i);try{

Thread.sleep(1000);

}catch(InterruptedException e){

e.printStackTrace();

}

}

}

}

四、线程优先级

每个线程都有优先级，优先级的高低只和线程获得执行机会的次数多少有关。

并非线程优先级越高的就一定先执行，哪个线程的先运行取决于CPU的调度;

默认情况下main线程具有普通的优先级，而它创建的线程也具有普通优先级。

Thread对象的setPriority(int x)和getPriority()来设置和获得优先级。

MAX_PRIORITY : 值是10

MIN_PRIORITY : 值是1

NORM_PRIORITY : 值是5(主方法默认优先级)

class Priority extendsThread{public voidrun() {for (int i = 0; i < 100; i++) {

System.out.println(getName()+"，优先级=" + getPriority() +"--"+i);

}

}

}public classPriorityDemo {public static voidmain(String[]args) {

Thread.currentThread().setPriority(7);for (int i = 0; i < 100; i++) {if(i == 10){

Priority p1= newPriority();

p1.setPriority(Thread.MAX_PRIORITY);

p1.start();

}if(i == 15){

Priority p2= newPriority();

p2.setPriority(Thread.MIN_PRIORITY);

p2.start();

}

System.out.println("main" +i);

}

}

}

Yield()方法

线程礼让:

暂停当前正在执行的线程对象，并执行其他线程；

Thread的静态方法，可以是当前线程暂停，但是不会阻塞该线程，而是进入就绪状态。

所以完全有可能：某个线程调用了yield()之后，线程调度器又把他调度出来重新执行。

class Yield implementsRunnable {public voidrun() {for (int i = 0; i < 100; i++) {

System.out.println(Thread.currentThread().getName()+ "--> " +i);if (i % 2 == 0) {

Thread.yield();//礼让

}

}

}

}public classYieldDemo {public static voidmain(String[]args) {

Yield y= newYield();new Thread(y, "A").start();new Thread(y, "C").start();

}

}

API 过时方法 -- 易死锁, , 不推荐使用

stop:终止线程

马上让线程停止运行,并释放该线程所持有的锁,该操作无法保证对象的内部状态正确;

suspend:挂起线程

使线程进入“阻塞”状态,该状态下CPU不会分给线程时间片,进入这个状态可以用来暂停一个线程的运行,在被resume方法调用前,不可用.

如果要suspend的目标线程对一个重要的系统资源持有锁，那么没任何线程可以使用这个资源直到要suspend的目标线程被resumed。

resume:恢复线程

恢复被suspend方法挂起的线程Java2开始已经废弃了suspend()和resume()方法，因为使用这两个方法可能会产生死锁，所以应该使用同步对象调用wait()和notify()的机制来代替suspend()和resume()进行线程控制。

五、线程的安全性问题

导致安全问题的出现的原因：

多个线程访问出现延迟。

线程随机性。

注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

我们可以通过Thread.sleep(long time)方法来简单模拟延迟情况。

六、线程同步

当多个线程访问同一份数据的时候，很容易出现线程安全的问题。

让多个操作在同一个时间段内只能有一个线程进行，其它线程要等到该线程完成后才可以继续执行。

经典的事例： 银行取钱

用户输入取款金额；

系统判断余额是否大于取款金额

若余额大于取款金额，取款成功；

若余额小于取款金额，取款失败。

例子分析：

账户类：Account

字段balance表示余额

取钱类：DrawMoney 线程类

字段a表示账户对象，money表示需要取的金额；

把取钱行为放在线程体里面；

提示：

public voidrun(){if(c.getBlance() >=money){

System.out.println(getName()+"，取走" +money);

Thread.sleep(100);

c.setBlance(c.getBlance()-money);

System.out.println("余额= " +c.getBlance());

}else{

System.out.println(getName()+ "余额不足,余额"+ c.getBlance() +",需要取走" +money );

}

}

解决问题：

方法一：

当发生以上情况时，java给我们提供了同步代码块

synchronized(obj){//obj表示同步监视器,是同一个同步对象/**.....

TODO SOMETHING*/}

方法二：synchronized返回值类型 方法名(参数列表){/**.....

TODO SOMETHING*/}

同步方法的同步监听器其实的是this

/*** 账号

**/

public classAccount {/*** 余额*/

private doubleblance;public Account(doubleblance) {this.blance =blance;

}public doublegetBlance() {returnblance;

}public void setBlance(doubleblance){this.blance =blance;

}public synchronized voiddraw(doubledrawMoney){if(getBlance() >=drawMoney) {

System.out.println(Thread.currentThread().getName()+"，取出" +drawMoney);try{

Thread.sleep(1);

}catch(InterruptedException e){

e.printStackTrace();

}//修改余额

setBlance(getBlance() -drawMoney);

System.out.println("余额= " +getBlance());

}else{

System.out.println("对不起余额不足");

}

}

}/*** 取钱操作*/

public classDrawThread extendsThread{/*** 账号*/

privateAccount a;/*** 取的钱*/

public doubledrawMoney;public DrawThread(String name,Account a,doubledrawMoney){super(name);this.a =a;this.drawMoney =drawMoney;

}/*** 当多条线程修改同一个共享资源数据的时候，将会导致数据安全问题*/

public voidrun(){/*synchronized (a) {

if(a.getBlance() >= drawMoney) {

System.out.println(getName()+"，取出" +drawMoney);

try {

Thread.sleep(1);

} catch (InterruptedExceptione) {

e.printStackTrace();

}

//修改余额

a.setBlance(a.getBlance() -drawMoney);

System.out.println("余额= " +a.getBlance());

}else{

System.out.println("对不起余额不足");

}

}*/a.draw(drawMoney);

}

}

以上内容是课堂笔记之后是今天作业：做一个售票的程序

要求三个窗口，一共50张票，随机售票，售完后求小明在每个窗口购票的几率：

public class Dome {　　　　　　　　　　　　　　　　　　　　　　　　　//主类

public static void main(String[] args) {　　　　　　　　　　　　　//主方法

Chuangkou c1 = new Chuangkou("窗口一");

Chuangkou c2= new Chuangkou("窗口二");

Chuangkou c3= new Chuangkou("窗口三");

Thread t1= new Thread(c1);　　　　　　　　　　　　　　　//新建三个线程

Thread t2 = newThread(c2);

Thread t3= newThread(c3);

t1.start();//三个线程同时运行

t2.start();

t3.start();

}

}public class Piao{　　　　　　　　　　　　　　　　　　　　　　　　//用来统计票数

public static String name = "目前只有这一种票";public static int piao = 1;

}public class Chuangkou implements Runnable{　　　　　　　　　　　//窗口类

publicString name;static int a = 0;　　　　　　　　　　　　　　　　　　　　　　　　//定义三个静态变量用来统计每个窗口一共卖的票

static int b = 0;static int c = 0;public Chuangkou(String name) {　　　　　　　　　　　　　　　//有参构造器

this.name =name;

}public void run(){　　　　　　　　　　　　　　　　　　　　　　　　//run方法

while(Piao.piao<49){　　　　　　　　　　　　　　　　　　　　//如果票数等于49就停止

try{

Thread.sleep(1/10);　　　　　　　　　　　　　　　　//经测试睡眠1/10的时间最有利于每个窗口的售票率

} catch(InterruptedException e) {

e.printStackTrace();

}synchronized(Piao.name){　　　　　　　　　　　　　　　　//同步，防止多个线程同时运行

System.out.println(name+"卖出了第 "+Piao.piao+++"票");

}switch(name){　　　　　　　　　　　　　　　　　　　　　　//统计窗口票数

case "窗口一":a+=1;break;case "窗口二":b+=1;break;case "窗口三":c+=1;break;

}

}

System.out.println(name+"售罄");if(Piao.piao == 50){　　　　　　　　　　　　　　　　　　　　　　//计算出小明购票几率

System.out.println("小明买窗口一的票的概率为"+(a/50.0));

System.out.println("小明买窗口二的票的概率为"+(b/50.0));

System.out.println("小明买窗口三的票的概率为"+(c/50.0));

}

}

}

目前这个作业还有问题，不知为什么小明的效率有时会出现两次，有时不出现，希望大神指导一下。