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 implements Runnable {
public void run() {
for (int i = 0; i < 200;i++) {
System.out.println(i);
}
}
}
public class MyThreadDemo {
public static void main(String[] args) {
for (int i = 0; i < 10;i++) {
if(i == 5){
MyThread t = new MyThread();
new Thread(t).start();
}
System.out.println("main" + i);
}
}
}
测试线程是否活着，可用线程对象的isAlive()方法。当线程处于就绪，运行，阻塞状态返回true。
当线程处于新建和死亡状态，返回false。
已死亡的线程是不可能通过start()方法唤醒线程的。
否则引发IllegalThreadStateException异常；
public class DieThreadDemo {
public static void main(String[]args) {
DeadThread dt = new DeadThread();
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 extends Thread {
public void run() {
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 class JoinDemo {
public static void main(String[]args) throws Exception {
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 implements Runnable {
public void run() {
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 extends Thread {
public void run() {
for (int i = 0; i < 10000; i++) {
System.out.println(getName() +"-" + i);
}
}
}
public class DaemonDemo {
public static void main(String[]args) {
Daemon d = new Daemon();
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 class SleepDemo {
public static void main(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 extends Thread{
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName()+"，优先级=" + getPriority() +"--"+ i);
}
}
}
public class PriorityDemo {
public static void main(String[]args) {
Thread.currentThread().setPriority(7);
for (int i = 0; i < 100; i++) {
if(i == 10){
Priority p1 = new Priority();
p1.setPriority(Thread.MAX_PRIORITY);
p1.start();
}
if(i == 15){
Priority p2 = new Priority();
p2.setPriority(Thread.MIN_PRIORITY);
p2.start();
}
System.out.println("main" + i);
}
}
}
Yield()方法
线程礼让:
暂停当前正在执行的线程对象，并执行其他线程；
Thread的静态方法，可以是当前线程暂停，但是不会阻塞该线程，而是进入就绪状态。
所以完全有可能：某个线程调用了yield()之后，线程调度器又把他调度出来重新执行。
class Yield implements Runnable {
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "--> " + i);
if (i % 2 == 0) {
Thread.yield();// 礼让
}
}
}
}
public class YieldDemo {
public static void main(String[]args) {
Yield y = new Yield();
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 void run(){
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 class Account {
/**
* 余额
*/
private double blance;
public Account(double blance) {
this.blance = blance;
}
public double getBlance() {
return blance;
}
public void setBlance(double blance){
this.blance = blance;
}
public synchronized void draw(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 class DrawThread extendsThread{
/**
* 账号
*/
private Account a;
/**
* 取的钱
*/
public double drawMoney;
public DrawThread(String name,Account a,double drawMoney){
super(name);
this.a = a;
this.drawMoney = drawMoney;
}
/**
* 当多条线程修改同一个共享资源数据的时候，将会导致数据安全问题
*/
public void run(){
/* 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 = new Thread(c2);
Thread t3 = new Thread(c3);
t1.start(); //三个线程同时运行
t2.start();
t3.start();
}
}
public class Piao{ //用来统计票数
public static String name = "目前只有这一种票";
public static int piao = 1;
}
public class Chuangkou implements Runnable{ //窗口类
public String 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));
}
}
}
目前这个作业还有问题，不知为什么小明的效率有时会出现两次，有时不出现，希望大神指导一下。
线程（java课堂笔记）
