黑马程序员-----程序员之路_____多线程

最新推荐文章于 2022-10-17 17:18:37 发布

小瓶子的瓶子

最新推荐文章于 2022-10-17 17:18:37 发布

阅读量563

点赞数

本文链接：https://blog.csdn.net/u012871223/article/details/16918151

版权

----------android培训、Java培训、期待与您交流！----------

一多线程概述

1、进程和线程：

进程：正在进行的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

线程：进程内部的一条执行路径或者一个控制单元。

两者的区别：一个进程至少有一个线程，进程在执行过程中拥有独立的内存单元，而多个线程共享内存。

2、jvm多线程的启动是多线程吗？

java的虚拟机jvm启动的是单线程，就有发生内存泄露的可能，而我们使用java程序没出现这样的问题，也就是jvm启动至少有两个线程，一个执行java程序，一个执行垃圾回收。所以是多线程。而执行java程序的那个线程为主线程，存在于mian方法中。

3、多线程的优势：

解决了多部分同时运行的问题，提高效率

4、线程的弊端：

线程太多会导致效率的降低，因为线程的执行依靠的是CPU的来回切换。

5、什么叫多线程以及多线程的特点：

一个进程中有多个线程，称为多线程。多线程的特点：随机性

6、实现多线程的方法：

实现多线程可以通过继承Thread类和实现Runnable接口。

在定义线程时，建议使用实现Runnable接口，因为几乎所有多线程都可以使用这种方式实现

(1)继承Thread

    定义一个类继承Thread类

    复写Thread类中的public void run()方法，将线程的任务代码封装到run方法中

    直接创建Thread的子类对象，创建线程

    调用start()方法，开启线程(调用线程的任务run方法)

    //另外可以通过Thread的getName()获取线程的名称。

(2)实现Runnable接口；

定义一个类，实现Runnable接口；

覆盖接口的public void run()的方法，将线程的任务代码封装到run方法中；

创建Runnable接口的子类对象

将Runnabl接口的子类对象作为参数传递给Thread类的构造函数，创建Thread类对象（原因：线程的任务

都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务）。

调用start()方法，启动线程。

两种方法区别：

(1)实现Runnable接口避免了单继承的局限性

(2)继承Thread类线程代码存放在Thread子类的run方法中

实现Runnable接口线程代码存放在接口的子类的run方法中；

package day11;
/*
 需求：简单的卖票程序
 多个窗口同时买票。
 创建线程的第二种方式：实现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方法中
 
 
 */
class Ticket implements Runnable //extends Thread
{
	private int tick=100;
	public void run()
	{
		while(true)
		{
			if(tick>0)
			System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
		}
	}
}
public 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();
		/*
		Ticket t1=new Ticket();
		Ticket t2=new Ticket();
		Ticket t3=new Ticket();
		Ticket t4=new Ticket();
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		*/
	}
}

7 、创建线程是为什么要复写run方法？

Thread类用于描述线程。Thread类定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。

练习：
创建两个线程，和主线程交替运行，原来线程都有自己的默认的名称，Thread -编号，该编号从0开始，currentThread():获取当前线程对象，getName()：获取线程名称。设置线程名称：setName或者构造函数。

class Test extends Thread
{
	//private String name;
	Test(String name)
	{
		super(name); 
		//this.name=name;
	}
	public void  run()
	{
		for(int x=0;x<60;x++)
		{
			System.out.println((Thread.currentThread()==this)+"..."+this.getName()+" run........."+x);
		}
	}
	}
class ThreadTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test t1=new Test("one");
		Test t2=new Test("two");
		t1.start();
		t2.start();
		for(int x=0;x<50;x++)
		{
			System.out.println("main......"+x);
		}
	}

}

8 、start()和run()方法有什么区别？

调用start方法方可启动线程，而run方法只是thread的一个普通方法，调用run方法不能实现多线程；

Start()方法:

start方法用来启动线程,实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态，并没有运行，一旦得到cpu时间片(执行权),就开始执行run()方法,这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束,此线程随即终止。

Run()方法:

run()方法只是Thread类的一个普通方法,如果直接调用Run方法,程序中依然只有主线程这一个线程,其程序执行路径还是只有一条，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到多线程的目的。

9、线程的几种状态：

新建：new一个Thread对象或者其子类对象就是创建一个线程，当一个线程对象被创建，但是没有开启，这个

时候，只是对象线程对象开辟了内存空间和初始化数据。

就绪：新建的对象调用start方法，就开启了线程，线程就到了就绪状态。在这个状态的线程对象，具有执行

资格，没有执行权。

运行：当线程对象获取到了CPU的资源。在这个状态的线程对象，既有执行资格，也有执行权。

冻结：运行过程中的线程由于某些原因(比如wait,sleep)，释放了执行资格和执行权。当然，他们可以回到运行

状态。只不过，不是直接回到。而是先回到就绪状态。

死亡：当线程对象调用的run方法结束，或者直接调用stop方法，就让线程对象死亡，在内存中变成了垃圾。

10、sleep()和wait()的区别：

(1)这两个方法来自不同的类，sleep()来自Thread类，而wait()来自Object类。

(2)sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，

要让b线程睡觉要在b的代码中调用sleep。而wait()是Object类的非静态方法

(3)sleep()释放资源不释放锁，而wait()释放资源释放锁；

(4)使用范围：wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用

二多线程的安全

package day11;
/*
 通过分析，发现，打印0，-1，-2等错票
 多线程的运行出现了安全问题
 问题的原因：
 	当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。
 	另一个线程参与进来执行，导致共享数据的错误	
 	解决办法：
 	对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行	
 	java对于多线程的安全问题提供了专业的解决方式
 	就是同步代码块	
 	synchronized(对象)
 	{
 		需要被同步的代码		
 	}
 	对象如同锁，持有锁的线程可以在同步中执行
 	没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁
 	同步的提前：
 	1，必须要有两个或者两个以上的线程
 	2必须是多个线程使用同一个锁
 	必须保证同步中只能有一个线程在运行
 	好处：解决了多线程的安全问题
 	弊端：多个线程需要判断锁，比较消耗资源
 
 */
class Ticket_1 implements Runnable 
{
	private int tick=100;
	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--);
				}
			}
		}
	}
}
public class TicketDemo1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Ticket_1 t=new Ticket_1();
		
		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、多线程安全问题：

(1)原因：当程序的多条语句在操作线程共享数据时(如买票例子中的票就是共享资源)，由于线程的随机性导致

一个线程对多条语句，执行了一部分还没执行完，另一个线程抢夺到cpu执行权参与进来执行，

此时就导致共享数据发生错误。比如买票例子中打印重票和错票的情况。

(2)解决方法：对多条操作共享数据的语句进行同步，一个线程在执行过程中其他线程不可以参与进来

2、Java中多线程同步是什么？

同步是用来解决多线程的安全问题的，在多线程中，同步能控制对共享数据的访问。如果没有同步，当一

个线程在修改一个共享数据时，而另外一个线程正在使用或者更新同一个共享数据，这样容易导致程序出

现错误的结果。

3、什么是锁?锁的作用是什么?

锁就是对象

锁的作用是保证线程同步，解决线程安全问题。

持有锁的线程可以在同步中执行，没有锁的线程即使获得cpu执行权，也进不去。

同步代码快的锁可以使任何对象，但是在进行多线程通信使用同步代码快时，必须保证同步代码快的锁的对象和，否则会报错。同步函数的锁是this，也要保证同步函数的锁的对象和调用wait、notify和notifyAll的对象是同一个对象，也就是都是this锁代表的对象。

静态同步函数的锁是class对象，如果同步函数被静态修饰后，使用的琐是该方法所在类的字节码

文件对象，类名.class

package day11;
/*
 如果同步函数被静态修饰后，使用的锁死什么呢？
 
 通过验证，发现不在是this ，因为静态方法中不可以定义this 
 静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象
 类名。class  该对象的类型是class
 
 静态的同步方法使用的锁是该方法所在类的字节码文件对象。类名。class
  */
class Ticket_4 implements Runnable 
{
	private static int tick=100;
	//Object obj=new Object();
	boolean flag=true;
	public void run()
	{
		if(flag)
		{
		while(true)
		{
			if(tick>0)
			{
				synchronized (Ticket_4.class)//同步代码块
				{
					try{Thread.sleep(10);}catch(Exception e){}
		
					System.out.println(Thread.currentThread().getName()+"code:"+tick--);	
					}
				}
			}
		}
		else 
			while(true)
		show();
			
	}
public static synchronized void show()//同步函数//this
				{
					if(tick>0)
					{
						try{Thread.sleep(10);}catch(Exception e){}
						System.out.println(Thread.currentThread().getName()+"show:"+tick--);
						}
					}
			}

 class StaticMethodDemo {

public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Ticket_4 t=new Ticket_4();
		
		Thread t1=new Thread(t);//创建了一个线程；
		Thread t2=new Thread(t);//创建了一个线程；
		
			t1.start();
			try{Thread.sleep(10);}catch(Exception e){}
			t.flag=false;
			t2.start();
			
			
		//Thread t3=new Thread(t);//创建了一个线程；
		//Thread t4=new Thread(t);//创建了一个线程；
		//t3.start();
		//t4.start();
		
	}

}

package day11;
/*
同步函数用的是哪一个锁呢？
函数需要被对象调用，那么函数都有一个所属对象的引用，就是this
所以同步函数使用的锁是this 。
通过改程序进行验证。
使用两个线程来卖票
一个线程在同步代码块中
一个线程在同步函数中
都在执行卖票动作
*/
class Ticket_3 implements Runnable 
{
	private int tick=300;
	Object obj=new Object();
	boolean flag=true;
	public void run()
	{
		if(flag)
		{
		while(true)
		{
			if(tick>0)
			{
				synchronized (this)//同步代码块
				{
					try{Thread.sleep(10);}catch(Exception e){}
		
					System.out.println(Thread.currentThread().getName()+"code:"+tick--);	
					}
				}
			}
		}
		else 
			while(true)
		show();		
	}
public synchronized void show()//同步函数//this
	{
		if(tick>0)
			{
				try{Thread.sleep(10);}catch(Exception e){}
				System.out.println(Thread.currentThread().getName()+"show:"+tick--);
			}
		}
	}
 class ThisLockDemo {
	public static void main(String[] args) {	
	Ticket_3 t=new Ticket_3();	
	Thread t1=new Thread(t);//创建了一个线程；
	Thread t2=new Thread(t);//创建了一个线程；
		
		t1.start();
		try{Thread.sleep(10);}catch(Exception e){}
		t.flag=false;
		t2.start();		
		//Thread t3=new Thread(t);//创建了一个线程；
		//Thread t4=new Thread(t);//创建了一个线程；
		//t3.start();
		//t4.start();		
	}
}

4、同步的前提:

(1)必须保证有两个以上线程

(2)必须是多个线程使用同一个锁，即多条语句在操作线程共享数据

(3)必须保证同步中只有一个线程在运行

5、同步的好处和弊端

好处：同步解决了多线程的安全问题

弊端：多线程都需要判断锁，比较消耗资源

6、同步的两种表现形式

(1)同步代码块:

可以指定需要获取哪个对象的同步锁,使用synchronized的代码块同样需要锁,但他的锁可以是任意对象

考虑到安全问题，一般还是使用同一个对象，相对来说效率较高。

格式：

synchronized(对象)

{

需同步的代码;

}

(2)同步函数

同步方法是指进入该方法时需要获取this对象的同步锁，在方法上使用synchronized关键字，

使用this对象作为锁，也就是使用了当前对象，因为锁住了方法，所以相对于代码块来说效率相对较低。

格式：

修饰词 synchronized 返回值类型函数名(参数列表)

{

需同步的代码;

}

在jdk1.5后，用lock锁取代了synchronized，个人理解也就是对同步代码块做了修改，

并没有提供对同步方法的修改，主要还是效率问题吧。

7、多线程的单例设计模式：保证某个类中内存中只有一个对象

(1)饿汉式:

class Single
{
	private static final Single s=new Single();
	private Single(){}
	public static Single getInstance()
	{
		return s;
	}
}

(2)懒汉式：

class Single
{
	private static Single s=null;
	private Single(){}
public static Single getInstance()
	{
	if(s==null)
	{
		synchronized(Single.class)
		{
		if(s==null)
			s=new Single();
		}
	}
		return s;
	} 
}

饿汉式和懒汉式的区别：

饿汉式是类一加载进内存就创建好了对象；

懒汉式则是类加载进内存的时候，对象还没有存在，只有调用了getInstance()方法时，对象才开始创建。

懒汉式是延迟加载，如果多个线程同时操作懒汉式时就有可能出现线程安全问题，解决线程安全问题

可以加同步来解决。但是加了同步之后，每一次都要比较锁，效率就变慢了，

所以可以加双重判断来提高程序效率。

如将上述懒汉式的Instance函数改成同步：

8 、死锁

两个线程对两个同步对象具有循环依赖时，就会发生死锁。即同步嵌套同步，而锁却不同。

三多线程之间的通信

1、多线程间通信概述

多线程间通讯就是多个线程在操作同一资源,但是操作的动作不同。

（1）为什么要通信

多线程并发执行的时候, 如果需要指定线程等待或者唤醒指定线程, 那么就需要通信.比如生产者消费者的问题，生产一个消费一个,生产的时候需要负责消费的进程等待,生产一个完成后需要唤醒负责消费的线程,同时让自己处于等待，消费的时候负责消费的线程被唤醒，消费完生产的产品后又将等待的生产线程唤醒，然后使自己线程处于等待。这样来回通信，以达到生产一个消费一个的目的。

（2）怎么通信

在同步代码块中, 使用锁对象的wait()方法可以让当前线程等待, 直到有其他线程唤醒为止，使用锁对象的notify()方法可以唤醒一个等待的线程，或者notifyAll唤醒所有等待的线程，多线程间通信用sleep很难实现，睡眠时间很难把握。

package day12;
/*
 线程间通讯：
 其实就是多个线程在操作同一个资源
 但是操作的动作不同 
 */
class Res
{
	private String name;
	private String sex;
	private boolean flag=false;
	
	public synchronized void set(String name,String sex)
	{
		if(flag)
			try{this.wait();}catch(Exception e){}
		this.name=name;
		this.name=sex;
		flag=true;
		this.notify();
	}
	public synchronized void out()
	{
		if(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(name+"....."+sex);
		flag=false;
		this.notify();
	}
}
class Input implements Runnable
{
	private Res r;
	Input(Res r)
	{
		this.r=r;
	}
	public void run()
	{
		int x=0;
		while(true)
		{
				if(x==0)
					r.set("mike","man");	
				else
					r.set("丽丽","女女女女");
					
				x=(x+1)%2;					
		}
	}
}
class Output implements Runnable
{
	private Res r;
	Output(Res r)
	{
		this.r=r;
	}
	public void run()
	{
		while(true)
		{
			r.out();
			}
		}
	}
 class InputOutputDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Res r=new Res();
		//匿名对象形式
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();		
		/*
		Input in=new Input(r);
		Output out=new Output(r);		
		Thread t1=new Thread(in);
		Thread t2=new Thread(out);
		t1.start();
		t2.start();
		*/
	}
}
 /*
 wait:
 notify();
 notifyAll(); 
  都使用在同步中，因为要对持有监视器（锁）的线程操作
  所以要使用在同步中，因为只有同步才具有锁
  为什么这些操作线程的方法要定义Object类中呢？
  因为这些方法在操作同步中线程时，都不许要标识他们所操作线程持有的锁
  只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒
  不可以对不同锁中的线程进行唤醒 
  也就是说，等待和唤醒时同一个锁
  而锁可以是任意对象，所以可以被任意对象调用的方法定义object类中
 */

2、等待唤醒机制 wait()与notify()

（1）wait()、notify()、notifyAll()

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程(一般是最先开始等待的线程)，而且不是按优先级。

notityAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

注意：sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

（2）为什么wait()、notify()、notifyAll()这些用来操作线程的方法定义在Object类中？

（1）这些方法只存在于同步中；

（2）使用这些方法时必须要指定所属的锁，即被哪个锁调用这些方法，只有同一个锁上的被等待线程可以被同一个锁上的notify唤醒，也即是说等待和唤醒必须是同一个锁。

（3）而锁可以是任意对象，所以任意对象调用的方法就定义在Object中。

3、生产者与消费者

package day12;
/*
 对于多个生产者和消费者
 为什么要定义while判断标记
 原因：让被唤醒的线程再次一次判断标记
 
  为什么定义notifyAll
  因为需要唤醒对方线程
  因为只用notify，容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待
 */
 class ProducerConsumerDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Resource r=new Resource();
		Producer pro=new Producer(r);
		Consumer con=new Consumer(r);
		
		Thread t1=new Thread(pro);
		Thread t2=new Thread(con);
		Thread t3=new Thread(pro);
		Thread t4=new Thread(con);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

}

class Resource
{
	private String name;
	private int count=1;
	private boolean flag=false;
	
	public synchronized void set(String name)
	{
		while(flag)
			try{wait();}catch(Exception e){}
		
		this.name=name+"--"+count++;
		
		System.out.println(Thread.currentThread().getName()+"。。。生产者"+this.name);
		flag=true;
		this.notifyAll();
	}
	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();
		}
	}
}

4、JDK1.5升级版本Lock和Condition

实现提供比synchronized方法和语句可获得的更广泛的锁的操作，可支持多个相关的Condition对象，Lock是个接口，锁是控制多个线程对共享数据进行访问的工具。

JDK1.5中提供了多线程升级的解决方案：将同步synchonized替换成了显示的Lock操作，将Object中的wait、notify、notifyAll替换成了Condition对象。该对象可以Lock锁进行获取。

Lock的方法摘要：

void lock() 获取锁。

Condition newCondition() 返回绑定到此 Lock 实例的新 Condition 实例。

void unlock() 释放锁。

Condition方法摘要：

void await() 造成当前线程在接到信号或被中断之前一直处于等待状态。

void signal() 唤醒一个等待线程。

void signalAll() 唤醒所有等待线程。

四线程的操作

1、停止线程

stop方法已经过时，如何停止线程？停止线程的方法只有一种，就是run方法结束。如何让run方法结束呢？开启多线程运行，运行代码通常是循环体，只要控制住循环，就可以让run方法结束，也就是结束线程。

特殊情况：当线程属于冻结状态，就不会读取循环控制标记，则线程就不会结束。为解决该特殊情况，可引入Thread类中的Interrupt方法结束线程的冻结状态；当没有指定的方式让冻结线程恢复到运行状态时，需要对冻结进行清除，强制让线程恢复到运行状态

2、void interrupt() 中断线程: 中断状态将被清除，它还将收到一个 InterruptedException

3、setDaemon(boolean on) 守护线程（后台线程）

setDaemon(boolean on):将该线程标记为守护线程或者用户线程。

当主线程结束，守护线程自动结束，比如圣斗士星矢里面的守护雅典娜，在多线程里面主线程就是雅典娜，守护线程就是圣斗士，主线程结束了，守护线程则自动结束。当正在运行的线程都是守护线程时，java虚拟机jvm退出；所以该方法必须在启动线程前调用；

守护线程的特点：守护线程开启后和前台线程共同抢夺cpu的执行权，开启、运行两者都没区别，但结束时有区别，当所有前台线程都结束后，守护线程会自动结束。

package day12;
/*
 Stop方法已经过时
 
  如何停止线程？
  只有一种，run方法结束
  开启多线程运行，运行代码通常是循环结构
  
  只要控制住循环，就可以让run方法结束，也就是线程结束
  
  特殊情况：
  当线程处于冻结状态。
  就不会读取到标记，那么线程就不会结束
  
  当没有指定的方式让冻结的线程回复到运行状态时，这时需要对冻结进行清除
  
  强制让线程恢复到运行状态中来这样就可以操作标记让线程结束
  
  Thread类提供该方法interrupt()
  
 */

class StopThread implements Runnable
{
	private boolean flag=true;
	public synchronized void run()
	{
		while(flag)
		{
			try
			{
				wait();
			}
			catch(InterruptedException e)
			{
				System.out.println(Thread.currentThread().getName()+"Exception");
				flag=false;
			}
			System.out.println(Thread.currentThread().getName()+".....run");
		}
	}
	public void changeFlag()
	{
		flag=false;
	}
}

class StopThreadDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		StopThread st=new StopThread();
		
		Thread t1=new Thread(st);
		Thread t2=new Thread(st);
		
		t1.setDaemon(true);
		t2.setDaemon(true);
		t1.start();
		t2.start();
		
		int num=0;
		while(true)
		{
			if(num++==60)
			{
				
				//st.changeFlag();
				//t1.interrupt();
				//t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"........"+num);
		}
		System.out.println("over");
	}

}

4、join 加入一个线程

void join() 等待该线程终止。

void join(long millis) 等待该线程终止的时间最长为 millis 毫秒。throws InterruptedException

特点：当A线程执行到B线程的join方法时，A就会等待B线程都执行完，A才会执行

作用: join可以用来临时加入线程执行；

5、多线程优先级：yield()方法

yield():暂停当前正在执行的线程对象，并执行其他线程

setPriority(int newPriority):更改线程优先级

int getPriority() 返回线程的优先级。

String toString() 返回该线程的字符串表示形式，包括线程名称、优先级和线程组

(1)MAX_PRIORITY:最高优先级(10级)

(1)Min_PRIORITY:最低优先级(1级)

(1)Morm_PRIORITY:默认优先级(5级)

----------android培训、Java培训、期待与您交流！----------

小瓶子的瓶子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员-----程序员之路_____多线程

----------android培训、Java培训、期待与您交流！----------一多线程概述1、进程和线程：进程：正在进行的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。线程：进程内部的一条执行路径或者一个控制单元。两者的区别：一个进程至少有一个线程，进程在执行过程中拥有
复制链接

扫一扫