多线程概念
-
进程：
进程是程序（任务）执行的过程
进程持有资源和线程 -
线程
线程是系统中的最小执行单元
一个进程有多个线程
线程共享进程资源 -
线程的交互：互斥&同步
多线程示例
Java对线程的支持体现在Thread类和Runnable接口
通过继承Thread类实现多线程，但是这种方式有一定的局限性。因为在java中只支持单继承，一个类一旦继承了某个父类就无法再继承Thread类，比如学生类Student继承了person类，就无法再继承Thread类创建的线程。
为了克服这种弊端，Thread类提供了另外一种构造方法Thread（Runnable target），其中Runnable是一个接口，它只有一个run（）方法。
package Base.Multprocess;
/**
* Created by Edwin_1993 on 2018/8/10.
*/
public class ThreadExample extends Thread {
public void run(){
System.out.println(getName() + " threadExample");
int count = 0;
boolean keepRunning = true;
while(keepRunning){
System.out.println((getName()+ " num:" + ++count));
if (count == 100){
keepRunning = false;
}
if (count%10 == 0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println(getName()+ " end");
}
public static void main(String args[]){
Thread thread = new ThreadExample();
thread.setName("ThreadExample");
thread.start();
Thread runnableThread = new Thread(new RunnableExample(),"Ms Runnable");
runnableThread.start();
}
}
class RunnableExample implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " RunnableExample");
int count = 0;
boolean keepRunning = true;
while (keepRunning) {
System.out.println((Thread.currentThread().getName() + " num:" + ++count));
if (count == 100) {
keepRunning = false;
}
if (count % 10 == 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
多线程的停止方式
-
stop()方法
这是一个错误的方法，会使得线程戛然而止，不知道完成了哪些以及如何清理。 -
interrupt方法
方法初衷并不是停止线程
下方代码无法正确结束线程。
package Base.Multprocess;
/**
* Created by Edwin_1993 on 2018/8/11.
*/
public class WrongWayStopThread extends Thread {
public static void main(String args[]){
WrongWayStopThread wrongWayStopThread = new WrongWayStopThread();
System.out.println("Thread starting ...");
wrongWayStopThread.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread interrupting ...");
wrongWayStopThread.interrupt();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread ending ...");
}
public void run(){
while (true){
// while (!this.isInterrupted()){
System.out.println("Thread is running ...");
long time = System.currentTimeMillis();
while((System.currentTimeMillis() - time) < 1000){
}
}
}
}
上述run方法改写后相当于使用了退出标志。
public void run(){
// while (true){
while (!this.isInterrupted()){
System.out.println("Thread is running ...");
long time = System.currentTimeMillis();
while((System.currentTimeMillis() - time) < 1000){
}
}
}
使用sleep()方法，线程进入了阻塞状态，此时再调用interrupte方法会使得interrupt状态被清除，使得this.isInterrupted()无效，且使得sleep方法被中断：InterruptedException 。
public void run(){
// while (true){
while (!this.isInterrupted()){
System.out.println("Thread is running ...");
long time = System.currentTimeMillis();
while((System.currentTimeMillis() - time) < 1000){
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
- 使用退出标志：
如下方代码中的keepRunning标志
package Base.Multprocess;
/**
* Created by Edwin_1993 on 2018/8/11.
*/
public class ArmyRunnable implements Runnable{
// volatile 保证了线程可以正确读取其它线程写入的值
// 一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
//
// 1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
//
// 2）禁止进行指令重排序
volatile boolean keepRunning = true;
@Override
public void run() {
while (keepRunning){
for(int i = 0;i <5;i++){
System.out.println(Thread.currentThread().getName() + "attack["+i+"]");
// t
Thread.yield();
}
}
System.out.println(Thread.currentThread().getName() + "end attack");
}
}
线程交互
-
争用条件：
当多个线程同时访问同一数据的时候，每个线程都在尝试操作该数据，从而导致数据被破环，这种情况叫做争用条件。 -
互斥：
互斥的实现：synchronized(intrinsic lock)
synchronized块中的代码，通过获取lockObj锁来执行。
private final Object lockObj = new Object();
public void transfer(int from ,int to, double amount){
// 通过synchronized进行互斥
synchronized (lockObj){
// if (energyBoxes[from] < amount){
// System.out.println("not enought energy");
// return;
// }
// 满足while条件时，任务被阻挡，不去竞争CPU资源。
while (energyBoxes[from] < amount){
try {
lockObj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(Thread.currentThread().getName());
energyBoxes[from] -= amount;
System.out.printf("从 %d 转移 %10.2f 单位能量到 %d",from,amount,to);
energyBoxes[to] += amount;
System.out.printf("能量总合: %10.2f", getTotalEnergy());
}
// 非互斥模式
// if (energyBoxes[from] < amount){
// System.out.println("not enought energy");
// return;
// }
// System.out.print(Thread.currentThread().getName());
// energyBoxes[from] -= amount;
// System.out.printf("从 %d 转移 %10.2f 单位能量到 %d",from,amount,to);
// energyBoxes[to] += amount;
// System.out.printf("能量总合: %10.2f", getTotalEnergy());
// 唤醒所有在lockObj上等待的线程。
lockObj.notifyAll();
}
- 同步
同步的实现：wait()/notify()/notifyAll()
这些方法都是object类的方法。
上述代码中
当运行条件不满足的时候，通过lockobj.wait()来将线程放入Wait set
当某一条线程顺利执行完成时，通过lockobj.notifyAll()来唤醒所有的等待线程。
网友评论