11.多线程
11.1什么是进程?
进程简单说,就是正在运行的程序,比如,在windows操作系统中,从任务管理器中可以看到,只要打开一个应用程序,就开启一个进程。
11.1什么是线程?
线程是比进程更小的执行单位,是用来执行进程中的内容的,线程也称为执行路径或控制单元。
一个进程中,至少有一个线程,这些进程通过抢夺CPU的执行时间片,获取被CPU处理的权利。完成程序的运行。比如,在windows操作系统中,可以同时打开多个应用程序,这些应用程序,似乎是在同时运行。事实上是因为CPU运算速度很快,实际上是在不同的进程间进行切换。想想,如果一个进程中,有多个线程,那么获取CPU执行权时,多线程机制就能执行多个程序块,进而提高效率,这就是多线程。确切的说,在同一时间片内,只有一个进程中的一条线程在执行。
开启多线程的目的是为了同时执行多部分代码。
11.2多线程的好处和弊端
好处:多个程序同时执行。
弊端:程序太多,效率低,易死机。
11.3 JVM中的线程
JVM开启至少有两条线程:一条线程执行主函数,一条线程执行垃圾回收。
11.4创建多线程的两种方式
第一种方式:继承Thread类
1,创建一个类继承Thread类,继承Thread类的类也称为线程类.
2,覆写run()方法.(run()方法中,封装的就是线程要执行的任务)
3,创建Thread子类的对象。
4,调用Thread类的start()方法,开启线程。
定义格式:
class类名extendsThread{
定义属性;
定义方法;
public void run(){//复写Thread类中的run方法
定义线程的任务;
}
示例代码:
class MyThread extends Thread{//创建一个类继承Thread类
private Stringname;//定义属性
MyThread(String name){//定义有参的构造函数
this.name=name;
}
public void run(){//覆写Thread类的run()方法,注意,run()方法中封装的就是线程的任务。
for (int i = 0; i < 10; i++) {
System.out.println(name+"...运行中....."+i);
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThread mt1=new MyThread("线程A");//创建线程对象
MyThread mt2=new MyThread("线程B");//创建线程对象
mt1.start();//开启线程,实际上是调用Thread类的start()方法。
mt2.start();//开启线程
}
}
/*
* 开启线程,线程会去执行run()方法中的内容.
* 运行结果:(每次运行的结果不一定相同)
* 线程A...运行中.....0
线程B...运行中.....0
线程A...运行中.....1
线程B...运行中.....1
线程A...运行中.....2
线程B...运行中.....2
线程B...运行中.....3
线程B...运行中.....4
线程B...运行中.....5
线程A...运行中.....3
线程A...运行中.....4
线程A...运行中.....5
线程A...运行中.....6
线程A...运行中.....7
线程A...运行中.....8
线程A...运行中.....9
线程B...运行中.....6
线程B...运行中.....7
线程B...运行中.....8
线程B...运行中.....9
*/
从上面可以看出,创建的两条线程:线程A和线程B,调用Thread类的start()方法后,都分别执行了run()方法中的代码。
那么,如果start()开启线程,目的是执行run()方法中的内容,为什么不直接运行run()方法呢?
因为,start()方法,目的是开启一条线程,start()方法内部调用了线程对象的run()方法,并由线程去执行内部内容。而,如果直接用线程对象调用run()方法,实际上只是调用了一般方法run(),并没有开启线程。
Java中每个线程都有默认的线程名称,如:Thread-x,x是数字,默认从零开始。也可以在创建线程对象时,自定义线程名称,可以通过Thread类的静态方法currentThread(),获取当前运行的线程对象,再调用getName()方法,获取线程的名称。通过setName()可以修改线程的名称。
示例代码:
class MyThread extends Thread{//创建一个类继承Thread类
private Stringname;//定义属性
public void run(){//覆写Thread类的run()方法,注意,run()方法中封装的就是线程的任务。
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"...运行中....."+i);//获取当前运行的线程名称
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThread mt1=new MyThread();//创建线程对象
MyThread mt2=new MyThread();//创建线程对象
// mt1.setName("线程A");这里还能修改线程的名称.
// mt2.setName("线程B");
mt1.start();
mt2.start();
}
}
/*
* 运行结果:
*
* Thread-0...运行中.....0
Thread-0...运行中.....1
Thread-0...运行中.....2
Thread-0...运行中.....3
Thread-0...运行中.....4
Thread-0...运行中.....5
Thread-0...运行中.....6
Thread-1...运行中.....0
Thread-1...运行中.....1
Thread-1...运行中.....2
Thread-1...运行中.....3
Thread-1...运行中.....4
Thread-1...运行中.....5
Thread-1...运行中.....6
Thread-1...运行中.....7
Thread-1...运行中.....8
Thread-1...运行中.....9
Thread-0...运行中.....7
Thread-0...运行中.....8
Thread-0...运行中.....9
*/
注意:一个线程对象的start()方法,只能被调用一次,重复调用一个线程对象的start()方法,
就会抛出:IllegalThreadStateException异常。
如:
class MyThread extends Thread{//创建一个类继承Thread类
private Stringname;//定义属性
public void run(){//覆写Thread类的run()方法,注意,run()方法中封装的就是线程的任务。
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"...运行中....."+i);//获取当前运行的线程名称
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThread mt1=newMyThread();//创建线程对象
MyThread mt2=new MyThread();//创建线程对象
// mt1.setName("线程A");这里还能修改线程的名称.
// mt2.setName("线程B");
mt1.start();
mt1.start();//调用两次mt1线程对象的start()
mt2.start();
}
}
异常信息:
Exception in thread "main" java.lang.IllegalThreadStateException
at java.lang.Thread.start(Thread.java:595)
at 多线程.ThreadDemo.main(ThreadDemo.java:17)
第二种方式:实现Runnable接口
1, 创建一个类实现Runnable接口。
2, 覆盖Runnable接口的run()方法,定义线程的任务内容。
3, 创建Runnable的子类对象。
4, 创建Thread类对象,并把实现Runnable的子类对象作为参数传递给Thread对象的构造函数。
5, 调用Thread对象的start()方法,开启线程。
定义格式:
class类名implements Runnable{
定义属性;
定义方法;
public void run(){//复写Thread类中的run方法
定义线程的任务;
}
//示例代码:
class MyThread implements Runnable{//创建一个类实现Runnable接口
private String name;//定义属性
public void run(){//覆写Runnable接口的run()方法,将线程任务封装。
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"...运行中....."+i);
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThread mt1=new MyThread();//创建线程对象
MyThread mt2=new MyThread();//创建线程对象
/*注意:实现Runnable接口的类的对象,并不是线程对象,只是将线程要执行的任务进行了封装,不能直接调用start()方法.
* 只能将此对象,作为参数传递给Thread类的构造函数,由Thread类去开启线程.
*/
//创建两个线程对象,将任务对象作为参数传递给Thread对象的构造函数.
Thread t1=new Thread(mt1);
Thread t2=new Thread(mt2);
//由线程对象,开启两条线程.
t1.start();
t2.start();
}
}
/*
* 运行结果:
Thread-0...运行中.....0
Thread-0...运行中.....1
Thread-0...运行中.....2
Thread-0...运行中.....3
Thread-0...运行中.....4
Thread-1...运行中.....0
Thread-1...运行中.....1
Thread-1...运行中.....2
Thread-1...运行中.....3
Thread-1...运行中.....4
Thread-1...运行中.....5
Thread-1...运行中.....6
Thread-1...运行中.....7
Thread-1...运行中.....8
Thread-1...运行中.....9
Thread-0...运行中.....5
Thread-0...运行中.....6
Thread-0...运行中.....7
Thread-0...运行中.....8
Thread-0...运行中.....9
*/
继承Thread类和实现Runnable接口有什么区别?
1,继承Thread类的类,就是一个线程类,可以直接调用start()方法,run()封装的线程任务,只是线程类中的一员.
2,实现Runnable接口的类,实际上将线程的任务进行了分离,进行了任务的封装,再由Thread类去执行线程中的任务.实现Runnable接口,可以避免单继承的局限性,而且,更方便于资源共享.
//如:卖票示例
A:继承Thread类:
class MyTicket extends Thread{//创建一个类继承Thread
private int num;//定义属性
private String name;//定义属性
MyTicket(int num,String name){//定义一个有参构造函数
super(name);
this.num=num;
}
public void run(){//覆写run()方法
for (int i = 1; i<= 20; i++) {
if(num>0){
System.out.println(Thread.currentThread().getName()+"正在卖第"+num--+"票");
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyTicket mt1=new MyTicket(10,"窗口1");//创建线程对象
MyTicket mt2=new MyTicket(10,"窗口2");//创建另一个线程对象.
mt1.start();//开启线程
mt2.start();//开启另一条线程
}
}
/*
打印结果:
窗口2正在卖第10票
窗口2正在卖第9票
窗口2正在卖第8票
窗口2正在卖第7票
窗口2正在卖第6票
窗口2正在卖第5票
窗口2正在卖第4票
窗口2正在卖第3票
窗口2正在卖第2票
窗口2正在卖第1票
窗口1正在卖第10票
窗口1正在卖第9票
窗口1正在卖第8票
窗口1正在卖第7票
窗口1正在卖第6票
窗口1正在卖第5票
窗口1正在卖第4票
窗口1正在卖第3票
窗口1正在卖第2票
窗口1正在卖第1票
*/
//由些可见,两个线程各卖出了10张票.
B:实现Runnable接口
class MyTicket implements Runnable{//创建一个类implements Runnable
private int num;//定义属性
private String name;//定义属性
MyTicket(int num){//定义一个有参构造函数
this.num=num;
}
public void run(){//覆写run()方法
for (int i = 1; i<= 20; i++) {
if(num>0){
System.out.println(Thread.currentThread().getName()+"正在卖第"+num--+"票");
}
}
}
}
public class ThreadDemo {
public staticvoid main(String[] args) {
MyTicket mt=new MyTicket(10);//创建Runnable子类对象,相当于创建线程任务对象.
Thread t1=new Thread(mt,"窗口1");//创建线程对象,把任务传递给线程对象的构造函数.
Thread t2=new Thread(mt,"窗口2");//创建另一个线程对象
t1.start();//开启线程
t2.start();//开启另一条线程
}
}
/*
打印结果:
窗口2正在卖第10票
窗口2正在卖第9票
窗口2正在卖第8票
窗口2正在卖第7票
窗口2正在卖第6票
窗口1正在卖第5票
窗口1正在卖第4票
窗口1正在卖第3票
窗口1正在卖第2票
窗口1正在卖第1票
*/
总结:由此可见,两个线程共同卖出了总的票数,10张票,所以,实现Runnable接口的多线程,可以轻松实现资源共享.当然,继承Thread类,也可以实现资源共享,需要将共同操作的资源分离出来,操作起来相对复杂一些.
11.5线程的状态
线程的5种状态:创建、运行、冻结、阻塞、消亡。
如图:
11.6线程安全问题
其实,多线程的运行过程是存在一定的安全隐患的.一般在理想状态下,安全问题的产生可能性很小,这里通过人为控制线程的状态,可以发现线程存在的安全隐患.
class MyTicket implements Runnable{//创建一个类implements Runnable
private int num;//定义属性
private String name;//定义属性
MyTicket(int num){//定义一个有参构造函数
this.num=num;
}
public void run(){//覆写run()方法
for (int i = 1; i<= 20; i++) {
if(num>0){
try {
Thread.sleep(10);//当线程执行到这一步时,会sleep(10毫秒)。
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖第"+num--+"票");
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyTicket mt=new MyTicket(10);//创建Runnable子类对象,相当于创建线程任务对象.
Thread t1=new Thread(mt,"窗口1");//创建线程对象,把任务传递给线程对象的构造函数.
Thread t2=new Thread(mt,"窗口2");//创建另一个线程对象
t1.start();//开启线程
t2.start();//开启另一条线程
}
}
/*
窗口2正在卖第10票
窗口2正在卖第9票
窗口2正在卖第8票
窗口2正在卖第7票
窗口2正在卖第6票
窗口1正在卖第5票
窗口1正在卖第4票
窗口1正在卖第3票
窗口1正在卖第2票
窗口1正在卖第1票
窗口2正在卖第0票
*/
从打印结果,可以看出,总票数为10张,却卖出了第0张票,这里就存在着线程的安全隐患.
因为,以上代码中创建了两条线程,当A线程在执行到Thread.sleep(10)方法时,就会被冻结,释放执行资格和执行权,此时CPU可能会切换到另一个线程B,当B线程执行到Thread.sleep(10)时,也会被冻结,此时,由于A线程可能睡眠时间到了,重新获取到CPU的执行权,开始执行:
System.out.println(Thread.currentThread().getName()+"正在卖第"+num--+"票");假设此时num=2,对num--后,num=1,A再次循环执行,当A线程执行到Thread.sleep(10)又会释放执行资格和执行权,此时可能会切换到B线程,B线程对num—后,就变成了0,输出。
线程安全问题产生的原因:
1,有多条线程在操作共享的资源。
2,多条线程操作的共享数据的代码有多条。
如何解决线程安全问题?
解决思路:当多条线程在操作共享数据时,在同一时间只允许一条线程操作共享数据,只有共享的数据操作完后,才允许下一条线程操作。
解决方式:Java中的同步代码块。
格式:
synchronized(Object obj){
需要被同步的代码;
}
obj:相当于一个锁,每个线程都会持有锁,只有持有锁的线程,才能执行同步代码块,其它线程必须等到持有的锁释放后,才能有一个线程再次持有锁,执行被同步的代码。也就是说,在同一时间内,只能有一个线程能够持有锁,并执行需要被同步的代码。同步解决了线程的安全问题,但是也存在一定的弊端。
同步的好处和弊端:
好处:解决了线程安全问题。
弊端:降低了效率,因为同步代码块外面的线程,每次都要判断锁。
总结:多个线程如果要完成同步,可以将线程要操作的共享数据加到同步代码块中,但必须要用同一个锁,这是同步的前提。注意区分,哪些是要被同步的代码,哪些不需要。
注意:同步代码块中的锁,是用Object类型接收的,也就是说可以是任意的对象,但是,必须要保证对象的唯一。否则,就没法实现多线程同步。
//示例代码:(加入同步代码块,解决线程安全问题)
class MyTicket implements Runnable{//创建一个类implements Runnable
Object obj=new Object();//创建Object对象,作为同步代码块的锁.
private int num;//定义属性
private String name;//定义属性
MyTicket(int num){//定义一个有参构造函数
this.num=num;
}
public void run(){//覆写run()方法
for (int i = 1; i<= 20; i++) {
synchronized(obj){//加入同步代码块
while(num>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖第"+num--+"票");
}
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyTicket mt=new MyTicket(10);//创建Runnable子类对象,相当于创建线程任务对象.
Thread t1=new Thread(mt,"窗口1");//创建线程对象,把任务传递给线程对象的构造函数.
Thread t2=new Thread(mt,"窗口2");//创建另一个线程对象
Thread t3=new Thread(mt,"窗口2");//创建另一个线程对象
Thread t4=new Thread(mt,"窗口2");//创建另一个线程对象
t1.start();//开启线程t1
t2.start();//开启线程t2
t3.start();//开启线程t3
t4.start();//开启线程t4
}
}
/*
窗口1正在卖第10票
窗口1正在卖第9票
窗口1正在卖第8票
窗口1正在卖第7票
窗口1正在卖第6票
窗口1正在卖第5票
窗口1正在卖第4票
窗口1正在卖第3票
窗口1正在卖第2票
窗口1正在卖第1票
*/
由此可见,解决了线程的安全问题.
11.7同步函数和静态同步函数
线程安全问题,用同步代码可以解决,同步函数和静态同步函数同样可以解决线程的安全问题.
同步函数的格式:
权限修饰符 synchronized返回值类型 方法名(){
需要被同步的代码;
}
静态同步函数格式:
权限修饰符 static synchronized返回值类型 方法名(){
需要被同步的代码;
}
同步函数和同步代码块有什么区别?
首先,同步代码块的锁是任意的对象,只要保证唯一性,就能实现同步.但同步函数和静态同步函数的锁是固定的,同步函数的锁,是本类对象的引用:this,而静态同步函锁的锁,是本类对象所属的字节码文件对象,可以通过对象的getClass()或类名.class属性获取.建议使用同步代码块.
//如:(以上代码可以用同步函数替代同步代码块)
class MyTicket implements Runnable{//创建一个类implements Runnable
Object obj=new Object();//创建Object对象,作为同步代码块的锁.
private int num;//定义属性
private String name;//定义属性
MyTicket(int num){//定义一个有参构造函数
this.num=num;
}
public void run(){//覆写run()方法
while(true){
show();//调用同步函数.
}
}
public synchronized void show(){//定义同步函数,将线程要操作的任务封装.
if(num>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖第"+num--+"票");
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyTicket mt=new MyTicket(10);//创建Runnable子类对象,相当于创建线程任务对象.
Thread t1=new Thread(mt,"窗口1");//创建线程对象,把任务传递给线程对象的构造函数.
Thread t2=new Thread(mt,"窗口2");//创建另一个线程对象
Thread t3=new Thread(mt,"窗口2");//创建另一个线程对象
Thread t4=new Thread(mt,"窗口2");//创建另一个线程对象
t1.start();//开启线程t1
t2.start();//开启线程t2
t3.start();//开启线程t3
t4.start();//开启线程t4
}
}
/*
窗口1正在卖第10票
窗口1正在卖第9票
窗口1正在卖第8票
窗口1正在卖第7票
窗口1正在卖第6票
窗口1正在卖第5票
窗口1正在卖第4票
窗口1正在卖第3票
窗口1正在卖第2票
窗口1正在卖第1票
*/
实现了同步.
11.8多线程的死锁
多线程的死锁,多发生在同步代码块的嵌套中,线程互相持有对方的锁,不释放,且线程又相互等待对方的锁释放。在实际开发中,要避免死锁的出现。
//死锁的代码示例:
class MyLock{//定义一个类分别创建两个对象,作为同步代码块的锁
public static final MyLocklock1=new MyLock();
public static final MyLocklock2=new MyLock();
}
class ThreadDemo implements Runnable{
private boolean flag;//定义标记
ThreadDemo(boolean flag){//定义构造函数,并把标记作为参数
this.flag=flag;
}
@Override
public void run() {//复写run()方法
while(true){//定义无限循环
if(flag){//标记为true时,线程A执行任务。
synchronized(MyLock.lock1){//同步代码块中嵌套同步代码块,持有lock1锁
System.out.println(Thread.currentThread().getName()+"..lock1...线程正在运行....");
synchronized(MyLock.lock2){//持有lock2
System.out.println(Thread.currentThread().getName()+"...lock2..线程正在运行....");
}
}
}else{//标记为false时,线程B执行任务。
synchronized(MyLock.lock2){//持有lock1
System.out.println(Thread.currentThread().getName()+"..lock2...线程正在运行....");
synchronized(MyLock.lock1){//持有lock2
System.out.println(Thread.currentThread().getName()+"...lock1..线程正在运行....");
}
}
}
}
}
}
public class DeadLock{
public static void main(String[]args){
//创建线程任务
ThreadDemo td1=new ThreadDemo(true);
ThreadDemo td2=new ThreadDemo(false);
//创建线程对象
Thread t1=new Thread(td1,"线程A");
Thread t2=new Thread(td2,"线程B");
//开启线程
t1.start();
t2.start();
}
}
/*
*线程A..lock1...线程正在运行....
*线程B..lock2...线程正在运行....
*
*发生死锁的现象
*/
以上代码中,当一个线程在执行时,只要另一个线程具有了CPU执行权时,就会发生相互在持有对方的锁,所以就发生了死锁的现象.
11.9线程间的通信
线程间的通信:多个线程在操作同一个资源,执行不同任务.
线程间的通信,涉及到对线程的状态操作,就是线程的等待、唤醒机制。
操作线程状态的方法:
1, wait():此方法,可以让线程处于冻结状态,被wait()的线程存储在线程池中。
2, notify():此方法,可以唤醒线程池中处于冻结状态的任意一个线程。
3, notifyAll():次方法,可以唤醒线程池中所有的线程。
注意:这几个方法,都封装在Object类,且这些方法必须要使用在同步中,因为这些方法是操作线程状态的方法,必须要明确操作的是哪个锁上的线程.因为,锁可以是任意的对象,所以这几个方法,被封装在了Object类中.
示例代码:(在线程中加入等待、唤醒机制)
需求:模拟电脑工厂生产电脑,生产一台,就停止生产,等到销售完成后再继续生产,并保证多线程的同步。
如图:
class Computer{//创建Computer类,这是线程要操作的同一资源
private int count=0;
private boolean flag=false;
private String name;
Computer(String name){
this.name="台"+name;
}
public synchronized void proComputer(){//对外提供生产的方法
while(flag)//判断标记,标记为true时,不生产。
try {
wait();//通过wait()方法,让线程冻结。
} catch (InterruptedException e) {
e.printStackTrace();
}
count++;
System.out.println(Thread.currentThread().getName()+"....正在生产第"+count+name);
flag=true;//生产完后,将标记改为true,代表生产结束,操作生产的线程,就会被wait()
notifyAll();//这里要唤醒线程池中,所有冻结的线程,否则,随着标记和判断,所有线程都会被wait();
}
public synchronized void sellComputer(){//对外提供销售的方法
while(!flag)//只有当flag为true时,代表生产完成,开始销售。
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"....正在销售第"+count+name);
flag=false;//销售完成后,标记改为false,销售的线程判断while(!flag)时,销售线程停止。
notifyAll();//这里要唤醒线程池中,所有冻结的线程,否则,随着标记和判断,所有线程都会被wait();
}
}
class Produce implements Runnable{//创建负责生产的类
private Computer c;
Produce(Computer c){//定义构造函数接收要操作的资源。
this.c=c;
}
public void run(){//线程的任务就是,Computer类中封装在proComputer()方法的内容。
while(true){
c.proComputer();
}
}
}
class Sell implements Runnable{
private Computer c;
Sell(Computer c){//定义构造函数接收要操作的资源。
this.c=c;
}
public void run(){//线程的任务就是,Computer类中封装在sellComputer()方法的内容。
while(true){
c.sellComputer();
}
}
}
public class ProAndSel{
public static void main(String[]args)throws InterruptedException{
//1,创建线程操作的资源
Computer c=new Computer("笔记本电脑");
//2,创建线程的任务
Produce pro=new Produce(c);
Sell sell=new Sell(c);
//3,创建线路程对象
Thread t1=new Thread(pro,"工厂A");
Thread t2=new Thread(pro,"工厂B");
Thread t3=new Thread(sell,"销售A");
Thread t4=new Thread(sell,"销售B");
//4,开启线程
t1.start();
t2.start();
t3.start();
t4.start();
}
}
在上面代码中各有两条线程负责生产和销售,通过判断标记来让线程等待和执行,在这里标记和判断要用while,不能用if,因为if只判断一次,而while多次判断,可以避免线程安全问题,且,四条线程都同属于一个线程池,如果用while判断标记,就必须用notifyAll进行唤醒,否则,所有线程都有可能被wait(),因此可见,四条线程,不论谁被wait,都会被唤醒。考虑到,生产和销售各有两条线程,在同一时间内,只有一条线程在执行,相互间交替执行。如何做到,生产完成后,只唤醒销售的线程;而销售完成后,只唤醒生产的线程.也就是只唤醒对方的线程,提高效率呢?
JDK1.5对此类问题进行了解决.
java.util.concurrent.locks.Lock接口
Lock,对锁的操作进行了封装,将原来同步代码块中获取锁和释放锁的隐式操作,变成了显示操作。在之前多条线程只要使用同一个锁,就都同属于一个线程池,这个锁只有一组操作线程状态的方法wait()、notify()、notifyAll(),能够操作线程池的所有线程。而Lock,可以让一个锁,产生多组线程操作的方法,可以分别操作同一个锁上的线程,让他们单独具备不同的线程状态。
Lock如使用:
Lock lock=new ReentrantLock();//获取锁对象.
Condition con1=lock.newCondition();//相当于获取一组操作锁上线程的方法。
Conditon con2=lock.newCondition();//获取另一组操作锁上线程的方法。
lock.lock();//调用lock()方法,获取锁。
try{
需要被同步的代码;
}
finally{{
lock.unlock();//释放锁
}
注意:释放锁的动作一定要放在finally代码块中执行。
示例代码:(使用JDK1.5如Lock锁,实现同步和相互唤醒)
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Computer{//创建Computer类,这是线程要操作的同一资源
private int count=0;
private boolean flag=false;
private String name;
Lock lock=new ReentrantLock();//获取锁对象
Condition con1=lock.newCondition();//创建两组操作线程的方法.一组操作生产.
Condition con2=lock.newCondition();//一组操作销售.
Computer(String name){
this.name="台"+name;
}
public void proComputer(){//对外提供生产的方法
lock.lock();//获取锁
try{
while(flag)//判断标记,标记为true时,不生产。
try {
con1.await();//让生产线程冻结。
} catch (InterruptedException e) {
e.printStackTrace();
}
count++;
System.out.println(Thread.currentThread().getName()+"....正在生产第"+count+name);
flag=true;//生产完后,将标记改为true,代表生产结束,操作生产的线程,就会被await()
con2.signal();//唤醒对方的线程。
}
finally{
lock.unlock();//释放锁。
}
}
public void sellComputer(){//对外提供销售的方法
lock.lock();
try{
while(!flag)//只有当flag为true时,代表生产完成,开始销售。
try {
con2.await();//让销售线程冻结
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"....正在销售第"+count+name);
flag=false;//销售完成后,标记改为false,销售的线程判断while(!flag)时,销售线程冻结。
con1.signal();//唤醒生产的线程。
}
finally{
lock.unlock();//释放锁
}
}
}
class Produce implements Runnable{//创建负责生产的类
private Computer c;
Produce(Computer c){//定义构造函数接收要操作的资源。
this.c=c;
}
public void run(){//线程的任务就是,Computer类中封装在proComputer()方法的内容。
while(true){
c.proComputer();
}
}
}
class Sell implements Runnable{
private Computer c;
Sell(Computer c){//定义构造函数接收要操作的资源。
this.c=c;
}
public void run(){//线程的任务就是,Computer类中封装在sellComputer()方法的内容。
while(true){
c.sellComputer();
}
}
}
public class ProAndSel{
public static void main(String[]args)throws InterruptedException{
//1,创建线程操作的资源
Computer c=new Computer("笔记本电脑");
//2,创建线程的任务
Produce pro=new Produce(c);
Sell sell=new Sell(c);
//3,创建线路程对象
Thread t1=new Thread(pro,"工厂A");
Thread t2=new Thread(pro,"工厂B");
Thread t3=new Thread(sell,"销售A");
Thread t4=new Thread(sell,"销售B");
//4,开启线程
t1.start();
t2.start();
t3.start();
t4.start();
}
}
总结:JDK1.5出现的Lock,实际上是替代了同步代码块synchronized,将锁变成了显示操作。Condition中的await()、signal()、signalAll()替代了,Object类中的wait()、notify()和notifyAll();且一个锁可以创建多组操作线程的方法,实现对线程状态的分别控制。
wait()和sleep()的区别?
1, wait():可以指定时间,也可以不指定。
sleep():必须要指定时间。
2, wait():线程释放执行权,释放锁。
sleep():线程释放执行权,但不释放锁。
12.0线程的其他方法
1. public void interrupt()
此方法可清除线程冻结的状态.是强制唤醒一个被冻结的线程,会发生异常:InterruptedException
此方法还可以用来结束线程.
class ThreadDemo implements Runnable{
private int count=1;
private boolean flag=true;
@Override
public void run() {
while(flag){
synchronized(this){
//System.out.println(count++);
count++;
if (count>10) {
try {
wait();//当count的值大于10时,线程被冻结,由主函数的线程中断方法,强制唤醒线程.因为会有异常,InterruptedException发生.
System.out.println("线程等待解除!");
} catch (InterruptedException e) {//这里接收主函数中调用interrupt()方法,中断线程时,所产生的异常.
flag=false;//在这里把标记改为false停止线程任务,完成对线程的结束控制.
System.out.println("线程标记为false,线程结束");
}
}
}
}
}
}
public class Demo {
public static void main(String[] args) {
ThreadDemo td=new ThreadDemo();
Thread t1=new Thread(td);
Thread t2=new Thread(td);
t1.start();//开启线程
t2.start();//开启线程
int count=0;
for(;;){
count++;
if(count>100){//通过循环递增count的值,如果大于50
System.out.println(count);
t1.interrupt();//就对线程t1,t2执行中断.
t2.interrupt();
break;
}
}
}
}
/*
打印结果:
101
线程标记为false,线程结束
*/
2. public final boolean isDaemon()
此方法,可以将线程设置后台线程,后台线程的特点是:当所有前台线程结后,后台线程自动结束.
如:
class ThreadDemo1 implements Runnable{
private int count=0;
@Override
public void run() {//t1 t2线程的任务是无限循环的
while(true){
synchronized(this){
System.out.println(Thread.currentThread().getName()+"...."+count++);
}
}
}
}
class ThreadDemo2 implements Runnable{
private int count=0;
@Override
public void run() {//t3 t4的任务是,当 count>100时,停止循环.
while(true){
synchronized(this){
System.out.println(Thread.currentThread().getName()+"...."+count++);
if(count>100){
break;
}
}
}
}
}
public class Demo {
public static void main(String[] args) {
ThreadDemo1 td1=new ThreadDemo1();
ThreadDemo2 td2=new ThreadDemo2();
Thread t1=new Thread(td1);
Thread t2=new Thread(td1);
Thread t3=new Thread(td2);
Thread t4=new Thread(td2);
//设置t1 t2为后台线程.
t1.setDaemon(true);
t2.setDaemon(true);
t1.start();//开启线程
t2.start();//开启线程
t3.start();//开启线程
t4.start();//开启线程
}
}
以上代码中,t1、 t2线程的任务是无限循环,而t3、t4的任务加了循环的次数判断,当大于100时,t3、t4的线程任务结束。因为t1、t2是后台线程,随着t3、 t4的结束,t1、 t2也相继结束任务。
3. public final void join()
此方法的作用是,哪个线程调用此方法,当前正在被执行的线程就把执行权交给调用join()方法的线程,自己处于冻结状态,直到调用join()方法的线程结束后,再抢夺CPU执行权。
4. public final void setPriority(int newPriority)
此方法,用于设置线程的优先级,线程的默认优先级为NORM_PRIORITY.
线程的优先级分为:
MAX_PRIORITY(最高,整数值:10)、NORM_PRIORITY(中等,整数值:5)、MIN_PRIORITY(最低,整数值:1).线程优先级越高被CPU先执行的几率越大。
5. public static void yield()
暂停当前线程,执行其他线程。
6. public String toString()
返回该线程的字符串表示形式,包括线程名称、优先级和线程组。
如:public class Demo {
public static void main(String[] args){
Thread t1=new Thread();
System.out.println(t1.toString());
}
}
/*
* 打印结果:Thread[Thread-0,5,main]
*/
总结:关于多线程,在应用中要注意线程的安全问题,可以利用同步代码块、同步函数、静态同步函数或JDK1.5的Lock,来实现多线程步.操作线程状态的方法,必须要用在同步中。同步中应该避免没有条件控制的无限循环,这样会导致一个线程进入后,无法结束。要避免多线程中,相互持有对方的锁,以免发生死锁。
---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流! ----------------------