@
Java 中传统多线程
线程初识
线程的概念
当代操作系统中,可以独立并发执行的基本单元
轻量:占用系统资源极少
独立:操作系统可以独立调度和分派的基本单元
共享:共享进程中的资源
实现线程
继承Thread类,重写run方法
实现Runnable接口,实现run方法
package com.xc.test.threadtest;
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException {
Thread threadA = new ThreadA();
threadA.setName("ThreadA");
threadA.start();
ThreadB threadB = new ThreadB();
Thread thread = new Thread(threadB);
thread.start();
while (true) {
Thread.sleep(1000);
System.out.println(3);
}
}
}
class ThreadA extends Thread {
public void run() {
while (true) {
System.out.println(this.getName() + ":" + 2);
}
}
}
class ThreadB implements Runnable {
public void run() {
while (true) {
System.out.println(4);
}
}
}
线程的生命周期
新建:线程刚刚创建完毕
可运行:启动线程后
运行:操作系统调度
阻塞/等待:等待某种资源或时间片到
消亡:退出run方法
常用API
类方法:针对当前运行线程
currentThread:获取当前运行线程的引用
yield:使得当前运行线程放弃当前时间片
sleep:使得当前运行线程休眠多少时间(单位是毫秒)
实例方法:针对指定线程
start:启动线程
setP:设置/获取线程优先级
setName/getName:设置/获取线程名称
setD:设置/获取线程的幽灵状态
线程同步
多线程共享数据的问题
多个线程并发访问同一个数据时,容易发生数据状态不稳定
使用锁机制完成线程同步(同-协同,步-调用顺序)
package com.xc.test.threadtest;
public class SysDemo {
public static void main(String[] args) {
Data data = new Data();
new ThreadC(data).start();
new ThreadC(data).start();
}
}
class Data {
int i;
public void process() {
System.out.println("Before:" + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
i++;
System.out.println("After:" + i);
}
}
class ThreadC extends Thread {
Data data;
public ThreadC(Data data) {
this.data = data;
}
public void run() {
super.run();
while (true) {
data.process();
}
}
}
Before:0
Before:0
After:1
After:2
Before:2
Before:2
After:3
Before:4
After:4
线程同步及实现机制
每个类一把锁,每个对象一把锁
只有获取锁的线程可以进入同步区域
class Data {
int i;
public void process() {
synchronized (this) {//对象锁(任意对象),同步块
System.out.println("Before:" + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
i++;
System.out.println("After:" + i);
}
}
}
class Data {
int i;
public synchronized void process() {//对象锁(当前对象),同步方法
System.out.println("Before:" + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
i++;
System.out.println("After:" + i);
}
}
Before:0
After:1
Before:1
After:2
Before:2
After:3
Before:3
After:4
线程间通讯
线程间通讯模型
wait:使当前线程进入指定对象的等待池
notify:从指定对象等待池中唤醒一个等待线程
notifyAll:从指定对象等待池中唤醒全部等待线程
只有获得该对象的锁后才可以调用上述方法
线程中通讯的实现
生产者:synchronized(obj){...;obj.notifyAll()}
消费者:synchronized(obj){obj.wait(),...;}
package com.xc.test.threadtest;
public class WnDemo {
public static void main(String[] args) {
Data2 data2 = new Data2();
new Producer(data2).start();
new Consumer(data2).start();
}
}
class Data2 {
int i;
public void add() {
synchronized (this) {
i++;
if (i % 5 == 0) {
notifyAll();
}
}
}
public void sub() {
synchronized (this) {
try {
this.wait();
} catch (InterruptedException e) {
}
}
System.out.println("Before:" + i);
i++;
System.out.println("After:" + i);
}
}
class Consumer extends Thread {
Data2 data;
public Consumer(Data2 data) {
this.data = data;
}
public void run() {
while (true) {
while (true) {
data.sub();
}
}
}
}
class Producer extends Thread {
Data2 data;
public Producer(Data2 data) {
this.data = data;
}
public void run() {
while (true) {
while (true) {
data.add();
}
}
}
}