------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
多线程
进程:是一个正在执行的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元
线程:就是进程中的一个独立的控制单元。线程在控制着进程的执行,一个进程中至少有一个线程。
JVM启动的时候会有一个进程java.exe,该进程中至少有一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称为主线程。其实JVM启动不止一个线程,还有负责垃圾回收机制的线程。
多线程的出现能让程序产生同时运行的效果,可以调高程序执行效率。
如何在自定义的代码中,自定义一个线程呢?
通过对api的查找,java已经提供了对线程这类事物的描述,就是Thread类。创建线程的第一种方式:继承Thread类。
步骤:
1, 第一类继承Thread
2, 复写Thread中的run方法。目的:当自定义代码存储在run方法中,调用run方法。
3, 调用线程的start方法。该方法两个作用:启动线程,调用run方法。
为什么要覆盖run方法?
Thread类用于描述线程,该类就定义了一个功能,用于存储线程要运行的代码,该存储功能就是run方法。也就是说Thread类中的run方法,用于存储线程要运行的代码。
小练习:
<span style="font-size:12px;">public class ThreadDemo {
public static void main(String[] args) {
//创建一个Demoa对象
Demoa d = new Demoa();
//开启一个线程
d.start();
//主线程
for(int i = 0; i < 60; i++)
System.out.println("Main...run"+i);
}
}
//用继承Thread的方法创建一个线程
class Demoa extends Thread {
//重写run方法
public void run(){
for(int i = 0; i < 60; i++)
System.out.println("Demo。。。run"+i);
}
}
</span>
发现运行结果每次都不一样。因为多个线程都获取cpu的执行权,cpu执行到谁,谁就运行。明确一点,在某一个时刻,只能有一个程序在运行(多核除外)。
cpu在做着快速的切换,已达到看上去是同时运行的效果。我们可以形象把多线程的运行形容为在互相抢夺cup的执行权。这就是多线程的一个特性:随机性。
谁抢到谁执行,至于执行多长,cpu说了算。
线程的几种状态:
被创建:等待启动,调用start启动。
运行状态:具有执行资格和执行权。临时状态(阻塞):有执行资格,但是没有执行权。
冻结状态:遇到sleep(time)方法和wait()方法时,失去执行资格和执行权,sleep方法时间到或者调用notify()方
法时,获得执行资格,变为临时状态。
消忙状态:stop()方法,或者run方法结束。
创建线程的第二种方式:实现Runnable接口
步骤:
1, 定义类实现Runnable接口
2, 覆盖Runnable接口中的run方法,将线程要运行的代码存放在该run方法中
3, 通过Thread类建立线程对象
4, 将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数?
因为自定义的run方法所属的对象时Runnable接口的子类对象,所以要让线程去指定指定对象的run方法,就必须明确该run方法所属对象。
5, 调用Thread类中的start方法开启线程,并调用Runnable接口子类的run方法
实现方式和继承方式有什么区别呢?
实现方式好处:避免了单继承的局限性。在建立线程时,建议使用实现方式。
继承Thread:线程代码存放在Thread子类run方法中
实现Runnable:线程代码存在接口中的子类run方法中
多线程的安全隐患
练习:
public class ThreadDemo2 {
public static void main(String[] args) {
//创建Ticket对象
Ticket t = new Ticket();
//开启线程
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}
//创建实现Runnable接口的Ticket类
class Ticket implements Runnable {
private int ticket = 100;
@Override
//覆盖Runnable接口run方法
public void run() {
while(true){
if(ticket > 0){
//当前线程睡眠100毫秒
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+"sale....."+ticket--);
}
}
}
}
发现运行结果出现了负票,出现了安全问题
问题原因:当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分分,还没有执行完,另一个线程参与进来执行,导致共享数据的错误。
解决方法:对多条操作共享数据的语句,只能让一个线程执行完。在执行的过程中,其他线程不可以参与执行。
Java对多线程的安全问题提供了专业的解决方式:
就是同步代码快:
synchronized(对象)
{
需要被同步的代码
}
对象如同锁,持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
同步的前提:
1,必须要有两个或者两个以上的线程
2,必须是多个线程使用同一个锁
必须保证同步中只有一个线程在运行
好处:解决了多线程的安全问题
弊端:多个线程需要判断锁,较为消耗资源。
如何寻找多线程的安全问题
1,明确哪些代码是多线程运行代码
2,明确共享数据
3,明确多线程代码中哪些语句是操作共享数据的
同步程序:
public class ThreadDemo2 {
public static void main(String[] args) {
//创建Ticket对象
Ticket t = new Ticket();
//开启线程
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}
//创建实现Runnable接口的Ticket类
class Ticket implements Runnable {
private int ticket = 100;
Object obj = new Object();
@Override
//覆盖Runnable接口run方法
public void run() {
while(true){
//给线程加同步锁
synchronized(obj){
if(ticket > 0){
//当前线程睡眠100毫秒
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+"sale....."+ticket--);
}
}
}
}
}
同步函数
格式:在函数上加上synchronized修饰符
锁定的是this对象
示例代码:
<span style="font-size:18px;">public class BankDemo {
public static void main(String[] args) {
Cus c = new Cus();
//开启线程
new Thread(c).start();
new Thread(c).start();
}
}
//Bank类
class Bank{
private int sum;
//同步函数
public synchronized void add(int n){
sum = sum + n;
try {
//睡眠10毫秒
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("sum="+sum);
}
}
//实现Runnable接口的Cus对象
class Cus implements Runnable{
private Bank b = new Bank();
//重写Runnable接口的run方法
@Override
public void run() {
for(int i= 0; i < 3; i++){
b.add(100);
}
}
}</span>
验证同步函数锁定的为this代码:
<span style="font-size:18px;">public class ThreadDemo2 {
public static void main(String[] args) {
//创建Ticket对象
Ticket t = new Ticket();
new Thread(t).start();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t.flag = false;
new Thread(t).start();
}
}
//创建实现Runnable接口的Ticket类
class Ticket implements Runnable {
private int ticket = 100;
boolean flag = true;
@Override
//覆盖Runnable接口run方法
public void run() {
if(flag){
while(true){
//给线程加同步锁 锁定this
synchronized(this){
if(ticket > 0){
//当前线程睡眠100毫秒
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+"..code..."+ticket--);
}
}
}
}else
while(true)
show();
}
//同步函数
public synchronized void show(){
if(ticket > 0){
//当前线程睡眠100毫秒
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+"....show...."+ticket--);
}
}
}</span>
静态同步函数
静态进内存,内存中没有本类对象,但是一定有该类对应的字节码文件对象。类名.class 该对象类型是Class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。类名.class
死锁
两个以上的运算单元,双方都在等待对方停止运行,以获取系统资源,但是没有一方提前退出时,这种状况,就称为死锁
同步中嵌套同步,但是所用的锁不同,就有可能出现死锁
死锁示例代码:
<span style="font-size:18px;">public class DeadLockDemo {
public static void main(String[] args) {
TestDead td = new TestDead(true);
TestDead td_2 = new TestDead(false);
//开启两个线程
new Thread(td).start();
new Thread(td_2).start();
}
}
class TestDead implements Runnable{
private boolean flag;
TestDead(boolean flag){
this.flag =flag;
}
@Override
public void run() {
if(flag){
//同步嵌套 锁定obj_1
synchronized(DeadLock.obj_1){
//锁定obj_2
System.out.println("if obj_1");
synchronized(DeadLock.obj_2){
System.out.println(DeadLock.obj_2);
}
}
}else{
//锁定obj_2
synchronized(DeadLock.obj_2){
System.out.println("else obj_2");
//锁定obj_1
synchronized(DeadLock.obj_1){
System.out.println("else obj_2");
}
}
}
}
}
//定义两个锁
class DeadLock{
static Object obj_1= new Object();
static Object obj_2 = new Object();
}
</span>
线程间通讯:其实就是多个线程操作同一个资源,但是操作的动作不同。
示例代码:
<span style="font-size:18px;">//共同操作的资源
class Res {
String name;
String sex;
}
//输入类
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 (x == 0) {
res.name = "mike";
res.sex = "man";
} else {
res.name = "丽丽";
res.sex = "女";
}
}
x = (x + 1) % 2;
}
}
}
//输出类
class Output implements Runnable {
//传入一个资源
private Res res;
public Output(Res res) {
this.res = res;
}
@Override
public void run() {
while (true) {
synchronized (res) {//同步锁
//取出资源属性
System.out.println(res.name + "...... " + res.sex);
}
}
}
}
//测试类
public class ThreadIoDemo {
public static void main(String[] args) {
//创建一个资源对象
Res res = new Res();
//创建输入线程
Input in = new Input(res);
//创建输出线程
Output out = new Output(res);
//开启线程
new Thread(in).start();
new Thread(out).start();
}
}
</span>
wait(),notify(),notifyAll():都使用在同步中,因为要对持有监视器(锁)的线程操作,所以要使用在同步中,因为只有同步才具有锁。
为什么这些操作线程的方法要定义在Object类中呢?
因为这些方法在操作同步中线程时,都必须要标识它们所操作线程持有的锁,只有同一个锁上的被等待线程,可以被同一个锁上notify唤醒,不可以对不同锁中的线程唤醒。也就是说,等待和唤醒必须是同一个锁,而锁可以是任意对象,所以可以被任意对象调用的方法定义在Object类中。
wait和sleep的区别
wait():释放cpu执行权,释放锁
sleep():释放cpu执行权,不释放锁
生产者消费者示例代码:
//测试类
public class ProducerCosumerDemo {
public static void main(String[] args) {
//建立资源对象
Resource res = new Resource();
//建立生产者对象
Producer p = new Producer(res);
//建立消费者对象
Consumer c = new Consumer(res);
//开启线程
new Thread(p).start();
new Thread(p).start();
new Thread(c).start();
new Thread(c).start();
}
}
//资源类
class Resource{
private String name;
private int count;
private boolean flag;
//生产方法
public synchronized void set(String name){
while(flag){
try {
this.wait();//等待线程
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
this.name = name+count++;
System.out.println(Thread.currentThread().getName()+"..."
+ "生产了。。。。。。."+this.name);
flag = true;
this.notifyAll();//唤醒所有线程
}
//消费方法
public synchronized void out(){
//判断标识
while(!flag){
try {
this.wait();//线程等待
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"..."
+ "消费。。。."+name);
flag = false;
//唤醒所有线程
this.notifyAll();
}
}
//生产者
class Producer implements Runnable{
private Resource res ;
Producer(Resource res){
this.res =res;
}
@Override
public void run() {
while(true)
res.set("商品");
}
}
//消费者
class Consumer implements Runnable{
private Resource res;
Consumer(Resource res){
this.res =res;
}
@Override
public void run() {
while(true)
res.out();
}
}
JDK1.5的多线程升级解决方案
将synchronized替换成显示Lock操作,将wait notify notifyAll替换成了Condition对象。该Condition对象可以通过Lock获取,并支持多个相关联的Condition对象。
代码:
package Test;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//测试类
public class ProducerCosumerDemo {
public static void main(String[] args) {
//建立资源对象
Resource res = new Resource();
//建立生产者对象
Producer p = new Producer(res);
//建立消费者对象
Consumer c = new Consumer(res);
//开启线程
new Thread(p).start();
new Thread(p).start();
new Thread(c).start();
new Thread(c).start();
}
}
//资源类
class Resource{
private String name;
private int count;
private boolean flag;
//创建锁对象
private Lock lock = new ReentrantLock();
//创建生产者Condition对象
private Condition condition_Pro = lock.newCondition();
//创建消费者Condition对象
private Condition condition_Con = lock.newCondition();
//生产方法
public void set(String name){
try{
lock.lock();//上锁
while(flag){
try {
condition_Pro.await();//生产者等待
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
this.name = name+count++;
System.out.println(Thread.currentThread().getName()+"..."
+ "生产了。。。。。。."+this.name);
flag = true;
condition_Con.signal();//唤醒一个消费者
}finally{
lock.unlock();//解锁
}
}
//消费方法
public synchronized void out(){
lock.lock();//上锁
try{
//判断标识
while(!flag){
try {
condition_Con.await();//消费者等待
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"..."
+ "消费。。。."+name);
flag = false;
condition_Pro.signal();//唤醒一个生产者
}finally{
lock.unlock();//解锁
}
}
}
//生产者
class Producer implements Runnable{
private Resource res ;
Producer(Resource res){
this.res =res;
}
@Override
public void run() {
while(true)
res.set("商品");
}
}
//消费者
class Consumer implements Runnable{
private Resource res;
Consumer(Resource res){
this.res =res;
}
@Override
public void run() {
while(true)
res.out();
}
}
结束线程
stop方法已经过时,结束线程只有一种方式,run方法结束。
开启多线程运行,运行代码通常是循环结构,只要控制住循环,就可以让run方法结束,也就是线程结束。
特殊情况:当线程处于了冻结状态,就不会读到标记,那么线程就不会结束。当没有指定的方式让冻结的线程恢复到
运行状态时,这时需要对状态进行清除,强制让线程恢复到运行状态中来,这样就可以操作标记让线程结束。
Thread类提供该方法interrupt();
练习代码:
public class ThreadOver {
public static void main(String[] args) {
Democ dc = new Democ();
//开启线程
new Thread(dc).start();
new Thread(dc).start();
for(int i = 0; i < 100 ; i++){
if( i == 60){
//调用改变标志方法
dc.changeFlag();
}
System.out.println(i);
}
}
}
class Democ implements Runnable{
//设置标志
private boolean flag = true;
@Override
public void run() {
while(flag)
System.out.println(Thread.currentThread().getName());
}
//改变标志
public void changeFlag(){
flag =false;
}
}
public class ThreadOver {
public static void main(String[] args) {
Democ dc = new Democ();
//开启线程
Thread t1 = new Thread(dc);
Thread t2 = new Thread(dc);
t1.start();
t2.start();
for(int i = 0; i < 61 ; i++){
if( i == 60){
//调用interrupt方法
t1.interrupt();
t2.interrupt();
}
System.out.println(i);
}
}
}
class Democ implements Runnable{
//设置标志
private boolean flag = true;
@Override
public synchronized void run() {
while(flag){
try {
wait();//等待
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName()
+"....Exception");
//把标志置为false
flag = false;
}
System.out.println(Thread.currentThread().getName()
+ "run");
}
}
}
守护线程:线程调用setDaemon()方法,并将其参数设置为true,这个线程就被标记为了守护线程。当正在运行的线程都是守护线程时,java虚拟机退出。该方法必须在启动线程前调用。
join:当A线程执行到了B线程的join()方法时,A就会等待,等B线程都执行完,A才会执行。join可以用来临时加入线程执行。
setPriority()设置线程的优先级