------- android培训、java培训、期待与您交流! ----------
多线程
1、进程和线程
进程:运行中的应用程序称为进程,拥有系统资源(CPU、内存)。
线程:进程中的一个独立控制单元,一个进程可以有多个线程。本身不拥有资源(共享所在进程的资源)。
主线程:Java 虚拟机启动的时候会有一个进程java.exe,该进程中至少有一个线程负责java程序的执行,而且这个线程运行的代码存在于main方法中。该线程即为主线程。
多进程:在同一个操作系统运行多个任务。
多线程:在同一个应用程序中有多个功能流同时运行。
多线程的意义:
(1)可以实现程序的并发执行效果,提高系统性能。
(2)在多线程中可以通过优先级管理,使重要的程序优先执行,提高CPU的处理效率。
(3)在多CPU系统中,可以把不同的线程在不同的CPU中执行,真正做到处理多任务。
2、创建线程方式一:继承Thread类
步骤:
(1)定义类继承Thread类。
(2)子类复写Thread中的run()方法,将线程运行的代码放到run()方法中。
(3)创建线程:建立子类对象的同时线程也就被创建了。
(4)通过调用start()开启线程。
示例:
class Demo extends Thread
{
public void run()
{
for(int x=0; x<60; x++)
System.out.println("demo run---"+x);
}
}
class ThreadDemo
{
public static void main(String[] args)
{
Demo d = new Demo();//创建好一个线程。
d.start();//开启线程并执行该线程的run方法。
//d.run();//仅仅是对象调用方法。创建了线程,但线程没有启动。
for(int x=0; x<60; x++)
System.out.println("主线程---"+x);
}
}
3、线程的四种状态
被创建:线程对象已经产生,但是尚未被启动。
运行:线程正在运行中。
冻结:由于某种原因(sleep或wait)导致真在运行的线程让出CPU并暂停自己的执行。
消亡:这个状态下表示该线程的run方法已经已经执行完毕了,已经相当于死亡了。
运行:线程正在运行中。
冻结:由于某种原因(sleep或wait)导致真在运行的线程让出CPU并暂停自己的执行。
消亡:这个状态下表示该线程的run方法已经已经执行完毕了,已经相当于死亡了。
4、创建线程的方式二:实现Runable接口
步骤:
(1)定义类实现Runnable接口。
(2)复写Runnable接口中的run方法,将线程要运行的代码存放在该run方法中。
(3)通过Thread类建立线程对象。
(4)将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
思考:为什么要将Runnable接口的子类对象传递给Thread的构造函数?
因为自定义的run方法所属的对象是Runnable接口的子类对象,所以要让线程去执行指定对象的run方法,就必须明确该run方法所属对象。
(5)调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
示例:
class Ticket implements Runnable
{
private int tick = 100;
public void run()
{
while(true)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);//创建了一个线程
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();//启动线程
t2.start();
t3.start();
t4.start();
}
}
重点:实现方式的好处是:避免了单继承的局限性(在定义线程时,建立使用实现方式)。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable:线程代码存在接口的子类的run方法。
5、线程安全问题
导致安全问题出现的原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。对此Java提供了一种专业解决方式,即同步代码块。
同步代码块格式:
synchronized(对象)
{
需要被同步的代码;
}
{
需要被同步的代码;
}
对象如同锁,持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
示例:
class Ticket implements Runnable
{
private int tick = 1000;
Object obj = new Object();
public void run()
{
while(true)
{
synchronized(obj)//同步代码块,相当于加锁
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}//特意使程序出现不安全状况
System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
}
}
}
}
}
class TicketDemo2
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
同步的前提:
(1)必须要有两个或者两个以上的线程。
(2)必须是多个线程使用同一个锁。
同步的好处:解决了多线程的安全问题。
同步的弊端:多个线程需要判断锁,较为消耗资源。
6、同步函数
格式:
在函数上加上synchronized修饰符即可。
示例:
class Ticket implements Runnable
{
private int tick = 100;
public void run()
{
while(true)
{
show();//调用同步函数
}
}
public synchronized void show()//同步函数
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"...sale : "+ tick--);
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);//创建线程
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
t1.start();//开启线程
t2.start();
t3.start();
}
}
思考:同步函数用的是哪个锁呢?
分析:函数需要被对象调用,那么函数都有一个所属对象引用,就是this。
结论:同步函数使用的锁是this。
结论:同步函数使用的锁是this。
如果同步函数被静态修饰后,使用的锁是什么呢?
静态的同步方法,使用的锁是该方法所在类的字节码文件对象,即: 类名.class。
7、线程间通信
示例:
生产消费商品:多个线程生产商品,多个线程消费商品。
要求:生产一个商品,就消耗一个商品。
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
public synchronized void set(String name)
{
while(flag)//让被唤醒的线程再一次判断flag。
try{this.wait();}catch(Exception e){}
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
flag = true;
this.notifyAll();//唤醒对方线程,因为只用notify时,容易出现只唤醒本方线程,
//对方线程未唤醒而导致程序中所有线程都等待。
}
public synchronized void out()
{
while(!flag)
try{wait();}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
flag = false;
this.notifyAll();
}
}
class Producer implements Runnable//生产商品
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.set("+商品+");
}
}
}
class Consumer implements Runnable//消费商品
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.out();
}
}
}
class ProducerConsumerDemo
{
public static void main(String[] args)
{
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);//生产线程
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);//消费线程
Thread t4 = new Thread(con);
t1.start();//启动线程
t2.start();
t3.start();
t4.start();
}
}
思考1:wait(),notify(),notifyAll()用来操作线程,为什么不定义在Thread类中而定义在Object类中?
(1)这些方法都使用在同步中,因为要对持有监视器(锁)的线程操作,所以都使用在同步中(只用同步才具有锁)。
(2)这些方法在操作同步中线程时,都必须要标识它们所属同步的锁。
(3)锁可以是任意对象,所以任意对象调用的方法一定定义在Object类中。
思考2:wait(),sleep()有什么区别?
wait()释放CPU资源,释放锁。
sleep()释放CPU资源,不释放锁。