- 前言
- 一、线程的状态
- 二、线程的生命周期
- 三、线程的几个通用方法
- 四、进程的优先级
- 五、多线程的运行问题
- 六、线程间通信
- 结果： 
- 总结
前言
本文主要介绍线程的状态，生命周期，线程方法应用，线程优先级，多线程运行问题线程间通信等知识
提示：以下是本篇文章正文内容，下面案例可供参考
一、线程的状态线程有以下几种状态：
新建（创建），就绪（可运行） 运行中，阻塞，终止状态。
二、线程的生命周期 三、线程的几个通用方法
①、sleep（long xxx）；
进程休眠
②、join()
进程插队
四、进程的优先级
java中进程优先级分为10等级——1~10，超过范围会报异常，主线程默认优先级为5.
五、多线程的运行问题各个线程之间是通过占用CPU资源时间来获取机会
各线程什么时候取得CPU时间，占用多久都是不可预测的
一个正在运行的进程在什么地方被暂停也不可估计。
例如以下一个银行存取款问题：
每次存100，取200；为了保证存取款时，不允许其他进程对余额进行操作，需要对bank对象加锁，使用关键字Synchronized实现，代码如下：
//银行类
package com.imooc.bank;
public class Bank {
private String account;// 账号
private int balance;// 账户余额
public Bank(String account, int balance) {
this.account = account;
this.balance = balance;
}
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
public int getBalance() {
return balance;
}
public void setBalance(int balance) {
this.balance = balance;
}
@Override
public String toString() {
return "Bank [账号：" + account + ", 余额：" + balance + "]";
}
// 存款
public synchronized void saveAccount() {
// 获取当前的账号余额
int balance = getBalance();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 修改余额，存100元
balance += 100;
// 修改账户余额
setBalance(balance);
// 输出存款后的账户余额
System.out.println("存款后的账户余额为：" + balance);
}
public void drawAccount() {
synchronized (this) {
// 在不同的位置处添加sleep方法
// 获得当前的帐户余额
int balance = getBalance();
// 修改余额，取200
balance = balance - 200;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 修改帐户余额
setBalance(balance);
System.out.println("取款后的帐户余额：" + balance);
}
}
}
package com.imooc.bank;
//取款进程
public class DrawAccount implements Runnable{
Bank bank;
public DrawAccount(Bank bank){
this.bank=bank;
}
@Override
public void run() {
bank.drawAccount();
}
}
package com.imooc.bank;
//存款进程
public class SaveAccount implements Runnable{
Bank bank;
public SaveAccount(Bank bank){
this.bank=bank;
}
public void run(){
bank.saveAccount();
}
}
//测试类
package com.imooc.bank;
public class Test {
public static void main(String[] args) {
// 创建帐户，给定余额为1000
Bank bank=new Bank("1001",1000);
//创建线程对象
SaveAccount sa=new SaveAccount(bank);
DrawAccount da=new DrawAccount(bank);
Thread save=new Thread(sa);
Thread draw=new Thread(da);
save.start();
draw.start();
try {
draw.join();
save.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(bank);
}
}
结果如图；
当我没使用关键字时，结果：
六、线程间通信
此时需要使用消费者，生产者的例子，生产者每次生产一个对象，消费者每次消费一个对象，数量小于0时消费者不可消费，数量大于1是生产者不可生产。
代码如图：
package com.imooc.queue;
public class Consumer implements Runnable{
Queue queue;
Consumer(Queue queue){
this.queue=queue;
}
@Override
public void run() {
while(true){
queue.get();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
package com.imooc.queue;
public class Producer implements Runnable{
Queue queue;
Producer(Queue queue){
this.queue=queue;
}
@Override
public void run() {
int i=0;
while(true){
queue.set(i++);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
```java
package com.imooc.queue;
public class Queue {
private int n;
boolean flag=false;
public synchronized int get() {
if(!flag){
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("消费："+n);
flag=false;//消费完毕，容器中没有数据
notifyAll();
return n;
}
public synchronized void set(int n) {
if(flag){
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("生产："+n);
this.n = n;
flag=true;//生产完毕，容器中已经有数据
notifyAll();
}
}
package com.imooc.queue;
public class Test {
public static void main(String[] args) {
Queue queue=new Queue();
new Thread(new Producer(queue)).start();
new Thread(new Consumer(queue)).start();
}
}
结果：总结
例如：以上就是今天要讲的内容，本文主要介绍线程的状态，生命周期，线程方法应用，线程优先级，多线程运行问题线程间通信等知识
