（一）线程的概念及使用
- 线程：在同一个程序中，同时运行多个独立的流程，每一个独立的流程就是一个线程
- 线程并发：一个程序中， 多个线程并发执行
- 主线程：但JVM启动后，加载类文件，发现main方法，为main方法创建一个线程，用于main方法执行，这个main创建的线程为主线程
- java中实现自定义线程类的方法：
继承java.lang.Thread类
实现java.lang.Runnable接口 - 继承Thread类：
自定义一个线程类继承Thread
重写Thread的run方法
创建自定义线程类对象
开启线程：调用自定义线程类的start方法
继承Thread类练习
ThreadADemo
package com.thread;
public class ThreadADemo extends Thread{
@Override
public void run(){
for (int i =0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);//获取当前线程名字
}
}
}
ThreadBDemo
package com.thread;
public class ThreadBDemo extends Thread{
@Override
public void run(){
for (int i =0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);//获取当前线程名字
}
}
}
MainDemo
package com.thread;
public class MainDemo {
public static void main(String[] args) {
/*
* 自定义线程类
*1.继承Thread类
* 2.重写run方法
* 3.创建自定义线程类对象
* 4.开启线程：调用Start()方法
* */
ThreadADemo threadADemo = new ThreadADemo();
threadADemo.start();
ThreadBDemo threadBDemo = new ThreadBDemo();
threadBDemo.start();
/*主线程JVM*/
for (int i = 0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);
}
/*输出结果
* main 0 一直到 main 99
* Thread-0 0 一直到 Thread-0 99
* Thread-1 0 一直到 Thread-1 99
* */
}
}
- 实现Runnable接口：
自定义一个线程类实现Runnable接口
重写Runnable的run方法
创建自定义线程类对象，并传入Thread对象中
开启线程，调用自定义线程的start（）方法
实现Runnable接口练习
ThreadADemo
package com.thread2;
public class ThreadADemo implements Runnable{
@Override
public void run(){
for (int i =0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);//获取当前线程名字
}
}
}
ThreadBDemo
package com.thread2;
public class ThreadBDemo implements Runnable{
@Override
public void run(){
for (int i =0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);//获取当前线程名字
}
}
}
MainDemo
package com.thread2;
public class MainDemo {
public static void main(String[] args) {
/*
* 自定义线程类
*1.继承Thread类
* 2.重写run方法
* 3.创建自定义线程类对象
* 4.开启线程：调用Start()方法
* */
ThreadADemo threadADemo = new ThreadADemo();
ThreadBDemo threadBDemo = new ThreadBDemo();
Thread thread1 = new Thread(threadADemo);
Thread thread2 = new Thread(threadBDemo);
thread1.start();;
thread2.start();
/*主线程JVM*/
for (int i = 0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);
}
/*输出结果
* main 0 一直到 main 99
* Thread-0 0 一直到 Thread-0 99
* Thread-1 0 一直到 Thread-1 99
* */
}
}
（二）线程的状态
- 新建状态
- 可运行状态
- 阻塞状态
- 运行状态
- 死亡状态
1.阻塞状态
- Thread的void sleep（long millis）方法用于使当前线程休眠指定的毫秒数,代码如下：
ThreadADemo
package com.thread3;
public class ThreadADemo extends Thread{
@Override
public void run(){
try {
sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i =0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);//获取当前线程名字
}
}
}
ThreadBDemo
package com.thread3;
public class ThreadBDemo implements Runnable{
@Override
public void run(){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i =0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);//获取当前线程名字
}
}
}
- sleep方法对线程的控制是十分不精确的
- join可以精确控制线程，也会导致线程阻塞
- join特点：如果当前线程调用了另外一个线程的join方法，当前线程会立即阻塞，直到另外一个线程运行完成
- 关于join的代码如下：
ThreadADemo
package com.thread5;
public class ThreadADemo extends Thread{
private Thread thread;
public ThreadADemo(Thread thread){
super();
this.thread = thread;
}
@Override
public void run(){
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"\t"+"我是线程A");//获取当前线程名字
}
}
ThreadBDemo
package com.thread5;
public class ThreadBDemo extends Thread{
@Override
public void run(){
System.out.println(Thread.currentThread().getName()+"\t"+"我是线程B");//获取当前线程名字
}
}
MainDemo
package com.thread5;
public class MainDemo {
public static void main(String[] args) {
ThreadBDemo threadBDemo = new ThreadBDemo();
ThreadADemo threadADemo = new ThreadADemo(threadBDemo);
threadADemo.start();
threadBDemo.start();
/*输出结果
* Thread-0 我是线程B
* Thread-1 我是线程A
* */
}
}
- join的阻塞问题：相互等对方完成，相关代码如下：
ThreadADemo
package com.thread6;
public class ThreadADemo extends Thread{
Thread threadB;
@Override
public void run(){
try {
threadB.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0 ; i<100;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);
}
}
}
ThreadBDemo
package com.thread6;
public class ThreadBDemo extends Thread{
Thread threadA;
@Override
public void run(){
try {
threadA.join(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0 ; i<100;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);
}
}
}
MainDemo
package com.thread6;
public class MainDemo {
public static void main(String[] args) {
ThreadBDemo threadBDemo = new ThreadBDemo();
ThreadADemo threadADemo = new ThreadADemo();
threadADemo.threadB = threadBDemo;
threadBDemo.threadA = threadADemo;
threadADemo.start();
threadBDemo.start();
}
/*输出结果
* Thread-0 0 到Thread-0 99
* Thread-1 0 到Thread-1 99
* */
}
（三）线程同步
- 被多个线程并发访问时，如果一个对象有可能出现数据不一致问题，那么这个对象称为线程不安全的对象,代码实例如下：
Account
package com.thread7;
public class Account {
private double blanace ;
public Account(double blanace) {
this.blanace = blanace;
}
public void cun(double blanace){
System.out.println("存款前的余额"+this.blanace);
blanace += blanace;
System.out.println("存款后的余额");
}
public void qu(double blanace){
System.out.println("取款前的余额"+this.blanace);
if (this.blanace>blanace){
this.blanace -=blanace;
System.out.println("取款后的余额"+this.blanace);
}else{
System.out.println("余额不足");
}
}
}
PersonA
package com.thread7;
public class PersonA extends Thread{
private Account account;
public PersonA(Account account) {
this.account = account;
}
@Override
public void run(){
for (int i = 0 ; i<5 ; i++){
account.cun(500);
}
}
}
PersonB
package com.thread7;
public class PersonB extends Thread{
private Account account;
public PersonB(Account account) {
this.account = account;
}
@Override
public void run(){
for (int i = 0 ; i<5 ; i++){
account.qu(1000);
}
}
}
主方法
package com.thread7;
public class Test {
public static void main(String[] args) {
Account account = new Account(10000);
PersonA personA = new PersonA(account);
PersonB personB = new PersonB(account);
personA.start();
personB.start();
}
}
/*输出结果
存款前的余额10000.0
存款后的余额
取款前的余额10000.0
存款前的余额10000.0
存款后的余额
存款前的余额9000.0
存款后的余额
存款前的余额9000.0
存款后的余额
存款前的余额9000.0
存款后的余额
取款后的余额9000.0
取款前的余额9000.0
取款后的余额8000.0
取款前的余额8000.0
取款后的余额7000.0
取款前的余额7000.0
取款后的余额6000.0
取款前的余额6000.0
取款后的余额5000.0
* */
-
synchronized同步代码块
格式：synchronized（对象）{
同步的代码
} -
同步可以解决安全问题的根本原因，就在那个对象上。该对象如同锁的功能，示例代码如下
package com.thread7;
public class Account2 {
private double blanace ;
Object object = new Object();//创建对象
public Account2(double blanace) {
this.blanace = blanace;
}
public void cun(double blanace){
//使用同步
synchronized (object){
System.out.println("存款前的余额"+this.blanace);
blanace += blanace;
System.out.println("存款后的余额");
}
}
public void qu(double blanace){
synchronized (object){
System.out.println("取款前的余额"+this.blanace);
if (this.blanace>blanace){
this.blanace -=blanace;
System.out.println("取款后的余额"+this.blanace);
}else{
System.out.println("余额不足");
}
}
}
}
- 同步方法：在函数上加上synchronized修饰即可。
格式:[修饰符] synchronized 返回值类型 方法名（参数列表） {}，示例代码如下：
package com.thread7;
public class Account3 {
private double blanace ;
public Account3(double blanace) {
this.blanace = blanace;
}
public synchronized void cun(double blanace){ //定义为同步方法
System.out.println("存款前的余额"+this.blanace);
blanace += blanace;
System.out.println("存款后的余额");
}
public synchronized void qu(double blanace){//定义为同步方法
System.out.println("取款前的余额"+this.blanace);
if (this.blanace>blanace){
this.blanace -=blanace;
System.out.println("取款后的余额"+this.blanace);
}else{
System.out.println("余额不足");
}
}
}
（四)线程通信
- 线程死锁
代码示例:
ThreadA
package com.thread9;
public class ThreadA extends Thread {
private Object a;
private Object b;
public ThreadA(Object a, Object b) {
this.a = a;
this.b = b;
}
@Override
public void run(){
System.out.println("ThreadA开始获取对象a的锁");
synchronized (a){
System.out.println("ThreadA开始获取对象b的锁");
synchronized (b){
}
System.out.println("ThreadA释放对象b的锁");
}
System.out.println("ThreadA释放对象a的锁");
}
}
ThreadB
package com.thread9;
public class ThreadB extends Thread {
private Object a;
private Object b;
public ThreadB(Object a, Object b) {
this.a = a;
this.b = b;
}
@Override
public void run(){
System.out.println("开始获取对象b的锁");
synchronized (b){
System.out.println("开始获取对象a的锁");
synchronized (a){
}
System.out.println("释放对象a的锁");
}
System.out.println("释放对象b的锁");
}
}
Test
package com.thread9;
public class Test {
public static void main(String[] args) {
Object a = new Object();
Object b = new Object();
ThreadA threadA = new ThreadA(a,b);
ThreadB threadB = new ThreadB(a,b);
threadA.start();
threadB.start();
}
}
/*ThreadA开始获取对象a的锁
开始获取对象b的锁
开始获取对象a的锁
释放对象a的锁
ThreadA开始获取对象b的锁
释放对象b的锁
ThreadA释放对象b的锁
ThreadA释放对象a的锁*/
- 线程死锁解决：wait和notify,代码如下：
ThreadA
package com.thread10;
public class ThreadA extends Thread {
private Object a;
private Object b;
public ThreadA(Object a, Object b) {
this.a = a;
this.b = b;
}
@Override
public void run(){
System.out.println("ThreadA开始获取对象a的锁");
synchronized (a){
try {
a.wait();
sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("ThreadA开始获取对象b的锁");
synchronized (b){
}
System.out.println("ThreadA释放对象b的锁");
}
System.out.println("ThreadA释放对象a的锁");
}
}
ThreadB
package com.thread10;
public class ThreadB extends Thread {
private Object a;
private Object b;
public ThreadB(Object a, Object b) {
this.a = a;
this.b = b;
}
@Override
public void run(){
System.out.println("开始获取对象b的锁");
synchronized (b){
System.out.println("开始获取对象a的锁");
synchronized (a){
a.notify();
}
System.out.println("释放对象a的锁");
}
System.out.println("释放对象b的锁");
}
}
- 线程通信：数据紊乱
package com.thread11;
public class Res {
String name;
String sex;
}
Input
package com.thread11;
public class Input implements Runnable{
private Res res;
public Input(Res res) {
this.res = res;
}
@Override
public void run() {
int x = 0;
while (true){
if (x == 0){
res.name = "杰克";
res.sex = "男";
}else {
res.name = "肉丝";
res.sex = "女";
}
x = (x+1)%2;
}
}
}
Output
package com.thread11;
public class Output implements Runnable{
private Res res;
public Output(Res res) {
this.res = res;
}
@Override
public void run() {
while (true){
System.out.println(res.sex+" "+res.name);
}
}
}
- 数据紊乱同步代码块，代码示例如下
Input
package com.thread12;
import com.thread11.Res;
public class Input implements Runnable{
private Res res;
public Input(Res res) {
this.res = res;
}
@Override
public void run() {
synchronized (Input.class){
int x = 0;
while (true){
if (x == 0){
res.name = "杰克";
res.sex = "男";
}else {
res.name = "肉丝";
res.sex = "女";
}
}
}
}
}
Output
package com.thread12;
import com.thread11.Res;
public class Output implements Runnable{
private Res res;
public Output(Res res) {
this.res = res;
}
@Override
public void run() {
while (true){
synchronized (Input.class){
System.out.println(res.sex+" "+res.name);
}
}
}
}
- 数据紊乱解决方案：
res
package com.thread13;
public class Res {
String name;
String sex;
boolean flag = false;
}
Input
package com.thread13;
import com.thread13.Res;
public class Input implements Runnable{
private Res res;
public Input(Res res) {
this.res = res;
}
@Override
public void run() {
int x = 0;
while (true){
synchronized (res){
if (res.flag){
try {
res.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (x == 0){
res.name = "杰克";
res.sex = "男";
}else {
res.name = "肉丝";
res.sex = "女";
}
x = (x+1)%2;
res.flag = true;
res.notify();
}
}
}
}
Output
package com.thread13;
import com.thread13.Res;
public class Output implements Runnable{
private Res res;
public Output(Res res) {
this.res = res;
}
@Override
public void run() {
while (true){
synchronized (res){
if (!res.flag){
try {
res.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(res.sex+" "+res.name);
res.flag = false;
res.notify();
}
}
}
}
479
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
