一 Java多线程
1.概念
进程:是一个正在执行的程序,每一个进程执行都会有一个执行顺序,该顺序是一个执行路径,或者叫控制单元,一个进程可以有多个线程。
线程:是进程的一个独立的控制单元,线程在控制着进程的执行。
线程从宏观上来说是串行执行,从微观上来说是并行执行。
2.Java中多线程
jvm在运行时会有一个java.exe进程,该程序中至少有一个线程是负责Java程序的执行。而且这个线程的运行代码存在于main代码块中。该线程称为主线程。其实jvm不止一个线程,还有一个线程,负责垃圾回收机制。
3.多线程特性
随机性;谁抢到谁执行,执行多长时间,cup说的算在没有人为控制的情况下。
二 创建线程
创建线程有两种方式:继承Thread和实现Runnable接口。
1.继承Thread类
创建步骤:
(1)定义类继承thread类。
(2)重写thread类中的run方法。
(3)调用线程的strat方法。该方法有俩个动作:启动线程,调用run方法。
注:run方法的目的:将自定义的代码存储到run方法中,让线程运行。
实例:有两个卖票窗口,卖不同的票。
class ThreadDemo extends Thread
{
ThreadDemo(Stringname){
super(name);
}
//覆盖run方法,
publicvoid run(){
inttick=100;
while(tick>0){
System.out.println(Thread.currentThread().getName()+"..."+tick);
tick--;
}
}
}
public class Test1
{
publicstatic void main(String[] args){
ThreadDemot1=new ThreadDemo("老人票窗口");
ThreadDemot2=new ThreadDemo("小孩票窗口");
t1.start();
t2.start();
}
}
第二种写法:使用内部匿名类
不创建类继承Thread,而是直接通过匿名内部类的特点直接在内部创建一个线程实例。该方法只能是线程中run方法逻辑比较简单的,否则代码看起来容易臃肿不易查看。
示例代码如下:
public class ThreadJCTest {
public static void createThreadByNestClass(){
Thread th= new Thread(){//匿名内部类
public void run(){
for (int x=0;x<10;x++){
System. err.println(Thread.currentThread().getName()+ "..." +x);
}
}
};
th.start();
}
public static void main(String[] args) {
createThreadByNestClass();
}
}
2.实现runable接口
分析步骤:
(1)定义类实现runable接口。
(2)覆盖runable接口中的run方法。
目的: 将线程要运行的代码放在run方法中。
(3)通过thread类创建线程对象。
(4)将runable接口的子类对象作为实际参数传递给thread类的构造方法。
目的: 自定义的run方法的所属的对象是runable接口的子类对象。所以要让线程指定哪个对象的run方法就必须明确该run方法的所属对象。
(5)调用thread类中的start的方法,开启线程并调用runable接口子类的run方法。
//实现runnable接口方式
class MyRunnable implements Runnable
{
//覆盖run方法,
private int tick=100;
publicvoid run(){
while(true){
if(tick>0){
System.out.println(Thread.currentThread().getName()+"..."+tick--);
}
elsebreak;
}
}
}
public class Test1
{
publicstatic void main(String[] args){
MyRunnablet=new MyRunnable();
Threadt1=new Thread(t,"小孩票窗口");
Threadt2=new Thread(t,"老人票窗口");
t1.start();
t2.start();
}
}
3.两种创建方式区别
上述2种方式都可以创建线程,而且从示例代码上看,线程执行的功能是一样的,那么这三种创建方式有什么不同呢?
这涉及到Java中多线程的运行模式,对于Java来说,多线程在运行时,有“多对象多线程”和“单对象多线程”的区别:
多对象多线程,程序在运行过程中创建多个线程对象,每个对象上运行一个线程。
单对象多线程,程序在运行过程中创建一个线程对象,在其上运行多个线程。
显然,从线程同步和调度的角度来看,多对象多线程要简单一些。上述2种线程创建方式,前一个属于“多对象多线程”,后者既可以使用“多对象多线程”,也可以使用“单对象单线程”。
俩种继承方式和实现方式有什么区别;
实现可以继承别的类,如果继承了thread类则无法继承别的类。
继承thread:线程运行代码存放在thread子类的run方法中。
实现runable:线程运行代码存放在实现该接口的run方法中。
实现的好处:避免了单继承的局限性,在定义线程时,建议使用多继承。
三 线程状态及切换
线程状态总的可分为五大状态:分别是创建、运行、冻结、等待/阻塞、消亡。用一个图来描述如下:
运行状态:经过start方法达到运行状态。
冻结状态:经过sleep(time)方法可以到达冻结状态,经过time时间后,重新回到运行状态。
在运行时,还可以经过wait()方法冻结状态。经过notity();方法回到运行状态。
阻塞状态:具备运行资格,但没有执行权,跟运行状态互通。在冻结状态被唤醒时,不一定马上就会运行,这就是临时状态。也称为阻塞状态。
死亡状态:在运行过程中经过stop();方法可以让线程消亡,run方法执行完后也会消亡。
状态之间的切换我们会用到下面方法:
*Thread()或者Thread(Runnable):构造线程。
*Thread.start:启动线程。
*Thread.sleep:将线程切换至休眠状态。
*Thread.interrupt:中断线程的执行。
*Thread.join:等待某线程结束。
*Thread.yield:剥夺线程在CPU上的执行时间片,等待下一次调度。
*Object.wait:将Object上所有线程锁定,直到notify方法才继续运行。
*Object.notify:随机唤醒Object上的1个线程。
*Object.notifyAll:唤醒Object上的所有线程。
四 线程的名称
线程都有自己的默认名称:thread-xxx,从0开始。
setName( ):设定线程名称;
getName( ); 获取线程名称;
thread.currentThread()方法,和this方法作用一样。前面是通用方法。获取当前线程对象的名称;
GroupName:每个线程都会默认在一个线程组里,我们也可以显式的创建线程组,一个线程组中也可以包含子线程组,这样线程和线程组,就构成了一个树状结构。
五 线程安全问题
线程同步,大部分情况下,我们是在针对“单对象多线程”的情况进行讨论,一般会将其分成两部分,一部分是关于“共享变量”,一部分关于“执行步骤”。
Java对于多线程的安全问题提供了专业的解决方式就是同步代码块。
安全问题如何确定:
(1)明确哪些代码是多线程运行代码。
(2)明确哪些是共享数据。
(3)明确多线程运行的代码中哪些语句是操作共享数据的。
同步的前提:
(1)须要有俩个或者两个以上的线程。
(2)必须是多个线程使用同一个锁。
(3)必须保证同步中只能有一个线程运行。
弊端:多个线程都需要判断锁,消耗资源。
1.控制共享变量
当我们在线程对象(Runnable)中定义了全局变量,run方法会修改该变量时,如果有多个线程同时使用该线程对象,那么就会造成全局变量的值被同时修改,造成错误。
实例:计算1到100的相加的值。
class MyRunnable implements Runnable {
int sum=0;
public void run(){
for (int x=1;x<=100;x++){
sum+=x;
try {
Thread. sleep(50);
}
catch (Exception e){
System. err.println("错误" );
}
System. err.println(Thread.currentThread().getName()+ "..."+x);
System. err.println(Thread.currentThread().getName()+ "..."+ sum);
}
System. err.println( "线程结束" +sum );
}
}
public class Test1
{
public static void main(String[] args) {
MyRunnable m= new MyRunnable();
Thread t= new Thread(m,"线程1");
Thread t1= new Thread(m,"线程2");
t.start();
t1.start();
}
}
正确结果是5050,输出出来确实10100,这时因为俩个线程同时对sum进行操作。
如何控制线程同步
既然线程同步有上述问题,那么我们应该如何去解决呢?针对不同原因造成的同步问题,我们可以采取不同的策略。
我们可以采取3种方式来控制共享变量。
(1)将“单对象多线程”修改成“多对象多线程”
publicclass Test1
{
public static void main(String[] args) {
MyRunnable m= new MyRunnable();
MyRunnable m1= new MyRunnable();
Thread t= new Thread(m,"线程1");
Thread t1= new Thread(m1,"线程2");
t.start();
t1.start();
}
}
输出结果为线程1和线程2都是5050.
(2)将“全局变量”降级为“局部变量”
既然是共享变量造成的问题,那么我们可以将共享变量改为“不共享”,即将其修改为局部变量。这样也可以解决问题,
(3)使用ThreadLocal机制
ThreadLocal是JDK引入的一种机制,它用于解决线程间共享变量,使用ThreadLocal声明的变量,即使在线程中属于全局变量,针对每个线程来讲,这个变量也是独立的。
2.控制执行步骤
安全问题原由:当多态语句操作同一线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来,导致共享数据的错误。如多窗口卖票出现负数的票和0票。
解决办法:对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与进来。
Java所提供的解决办法中,synchronized是一个非常重要的关键字。它的原理和数据库中事务锁的原理类似。我们在使用过程中,应该尽量缩减synchronized覆盖的范围,原因有二:
1)被它覆盖的范围是串行的,效率低;
2)容易产生死锁。
所以我们应该把需要同步的内容集中在一起,尽量不包含其他不相关的、消耗大量资源的操作
(1)同步代码块:
格式:synchronized( 对象 ){ 需要被同步的代码块 }
对象如同锁,持有锁的对象才能在同步代码块中执行,没有持有锁的线程即使获得cpu的执行权,也进不去。
示例:模拟卖票时出现0和负数的票。
class MyRunnable implements Runnable
{
//覆盖run方法,
private int tick=100;
publicvoid run(){
while(true){
if(tick>0){
try{
Thread.sleep(10);
}
catch(Exceptione){
thrownew RuntimeException("error");
}
System.out.println(Thread.currentThread().getName()+"..."+tick--);
elsebreak;
}
}
}
}
public class Test1
{
publicstatic void main(String[] args){
MyRunnablet=new MyRunnable();
Threadt1=new Thread(t,"小孩票窗口");
Threadt2=new Thread(t,"老人票窗口");
t1.start();
t2.start();
}
}
输出结果中可能会出现0和负数票,这里也能体现出多线程的随机性。
解决办法:
class MyRunnable implements Runnable
{
//覆盖run方法,
private int tick=100;
publicvoid run(){
while(true){
//同步锁
synchronized(this){
if(tick>0){
try{Thread.sleep(10); }catch(Exceptione){throw new RuntimeException("error");}
System.out.println(Thread.currentThread().getName()+"..."+tick--);
}
elsebreak;
}
}
}
}
public class Test1
{
publicstatic void main(String[] args){
MyRunnablet=new MyRunnable();
Threadt1=new Thread(t,"小孩票窗口");
Threadt2=new Thread(t,"老人票窗口");
t1.start();
t2.start();
}
}
(2)同步函数
在线程运行的同步代码中的函数上加上synchronized.
注意,必须是线程操作共享数据的函数上加入同步函数。
class MyRunnable implements Runnable
{
//覆盖run方法,
private int tick=100;
booleanflag=true;
publicvoid run(){
while(flag){
show();
}
}
//同步函数
publicsynchronized void show(){
if(tick>0){
try{Thread.sleep(10); }catch(Exceptione){throw new RuntimeException("error");}
System.out.println(Thread.currentThread().getName()+"..."+tick--);
}
elseflag=false;
}
}
public class Test1
{
publicstatic void main(String[] args){
MyRunnablet=new MyRunnable();
Threadt1=new Thread(t,"小孩票窗口");
Threadt2=new Thread(t,"老人票窗口");
t1.start();
t2.start();
}
}
注意:
在使用synchronized关键字时候,应该尽可能避免在synchronized方法或synchronized块中使用sleep或者yield方法,因为synchronized程序块占有着对象锁,你休息那么其他的线程只能一边等着你醒来执行完了才能执行。不但严重影响效率,也不合逻辑。
同样,在同步程序块内调用yeild方法让出CPU资源也没有意义,因为你占用着锁,其他互斥线程还是无法访问同步程序块。当然与同步程序块无关的线程可以获得更多的执行时间。
同步函数用的哪个锁呢?
函数需要被对象调用,那么函数都有一个所属对象引用,就是this。所以同步函数的锁是this。
静态同步函数用哪个锁?
因为静态方法中不可以定义this,所有不是this对象。
静态进内存时,内存中还没有对象,但是一定有该类对应的字节码文件对象,类名.class 该对象的类型是Class.
实例:单例模式。
class Single{
private static Single s =null;
private Single(){
}
public static Single getinstends(){
if(s ==null){//双重判断,减少资源消耗。
//存在多线程安全问题,同步代码块,代码块对象为本类对象,也可以是s.class,防止实例化多个对象。
synchronized (s) {4
//当A程序进来停止住,B程序再进来会实例化多个对象
if(s ==null){
s= new Single();
}
}
}
return s ;
}
}
六 死锁
线程发生死锁可能性很小,即使看似可能发生死锁的代码,在运行时发生死锁的可能性也是小之又小。
同步中嵌套同步,且锁不一样时,容易发生死锁。
public class Sisuotest implements Runnable{
booleanb=true;
Sisuotest(booleanb){
this.b=b;
}
publicvoid run (){
if(b){
synchronized(MyLock.s1) {
System.err.println("if--a--");
synchronized(MyLock.s2) {
System.err.println("if--a--");
}
}
}
else{
synchronized(MyLock.s2) {
System.err.println("else--a--");
synchronized(MyLock.s1) {
System.err.println("else--a--");
}
}
}}
publicstatic void main(String[] args) {
Threadt=new Thread(new Sisuotest (true));
Threadt1=new Thread(new Sisuotest (false));
t.start();
t1.start();
}
}
class MyLock{
staticMyLock s1=new MyLock();
staticMyLock s2=new MyLock();
}
七 线程间通信
就是多个线程操作同一资源,但是操作的动作不同。
示例:生产者与消费者
1.等待唤醒机制
wait(); 当前线程等待
notify(); 唤醒线程
notifyall(); 唤醒全部线程
这三个方法都使用在同步中,因为要对持有监视器(锁)的线程操作。所以要使用在同步中,只有同步才有锁。
为什么这些方法要定义到Object类中呢?
因为这些方法在操作同步中的线程时,都必须要标示他们所操作的线程持有的锁,只有同一个锁上的被等待的线程,才可以被同一锁上的notify唤醒。也就是所等待和唤醒必须是同一个锁。
而锁可以是任意对象,所以可以被任意对象调用的方法定义在Object类中。
等待的线程都放在线程池中,临时存放,当notify唤醒时唤醒的是线程池中的线程,线程池中有N多线程,那么要唤醒谁呢?通常唤醒第一个被等待的。
生产者与消费者例子:
当出现多个线程,例如多个生产者和多个消费者时,需要每次判断标记用while不能用if
如果用while也可能会出现全部等待的情况下,所以唤醒时需要全部唤醒用notifyall.
class Resource
{
privateString name;
privateint age;
privateboolean flag=false;
publicsynchronized void set(String name,int age){
//如果有资源,需要等待,取出资源。
if(flag){
try{wait(); }catch(Exception e){ throw new RuntimeException("等待失败"); }
}
this.name=name;
this.age=age;
flag=true;
notify();
}
publicsynchronized void out(){
//如果没有资源需要等待,存入资源。
if(!flag){
try{wait(); }catch(Exception e){ throw new RuntimeException("等待失败"); }
}
System.out.println("name:"+name+"age"+age);
flag=false;
notify();
}
}
//生产者
class Input implements Runnable
{
privateResource r;
Input(Resourcer){
this.r=r;
}
publicvoid run(){
intx=0;
while(true){
if(x==0){
r.set("张三",30);
}
else
r.set("李四",40);
x=(x+1)%2;
}
}
}
//消费者
class Output implements Runnable
{
privateResource r;
Output(Resourcer){
this.r=r;
}
publicvoid run(){
while(true)
r.out();
}
}
public class Test1
{
publicstatic void main(String [] args){
Resourcer=new Resource();
Inputi=new Input(r);
Outputo=new Output(r);
newThread(i).start();
newThread(o).start();
}
}
Jdk1.5中提供了多线程的解决方案。本方只唤醒对方的线程,不在全部唤醒。
将同步synchronized替换成显示的lock操作。
将object中的wait(),notify(),notifyall(),替换成condition对象。
改对象可以lock锁,进行获取。
//生产者与消费者。
import java.util.concurrent.locks.*;
class Resource
{
privateString name;
privateint count;
privateboolean flag=false;
privateLock lock=new ReentrantLock();
Conditioncondition_pro=lock.newCondition();
Conditioncondition_con=lock.newCondition();
publicvoid setProducer(String name)throws Exception{
lock.lock();//获取锁。
try{
while(flag)//判断标记
condition_pro.await();
this.name="..."+count++;
System.out.println(Thread.currentThread().getName()+"...生产..."+this.name);
flag=true;
condition_con.signal();
}
finally{
lock.unlock();
}
}
publicvoid getConsumer()throws Exception{
try{
lock.lock();//获取锁;
while(!flag)//判断锁标记
condition_con.await();//消费者等待;
System.out.println(Thread.currentThread().getName()+".消费."+this.name);
flag=false;
condition_pro.signal();
}
finally{
lock.unlock();
}
}
}
//生产者
class Producer implements Runnable
{
privateResource r;
Producer(Resourcer){
this.r=r;
}
publicvoid run(){
while(true){
try{
r.setProducer("商品");
}
catch(Exceptione){
thrownew RuntimeException("存入错误");
}
}
}
}
//消费者
class Consumer implements Runnable
{
privateResource r;
Consumer(Resourcer){
this.r=r;
}
publicvoid run(){
while(true){
try{
r.getConsumer();
}
catch(Exceptione){
thrownew RuntimeException("存入错误");
}
}
}
}
public class Test1
{
publicstatic void main(String[] args){
Resourcer=new Resource();
newThread(new Producer(r)).start();
newThread(new Consumer(r)).start();
}
}
八 停止线程
stop方法已过时。
如何停止线程?
只有一种方法,让run方法结束,开启多线程运行,运行代码通常是循环结构,只要控制住循环,就可以让run党法结束,也就是线程结束。
特殊情况:
当线程处于冻结状态,就不会读取到标记,那么线程就不会结束。
当没有指定的方式让线程从冻结状态恢复到运行状态时,这时需要对冻结状态进行清除,强制让线程恢复到运行状态中来,这样就可以操作标记让线程结束。
Thread类提供了该方法interrupt();
public class StopThread implements Runnable{
boolean flag= true ;
public void changflag(){
flag= false ;
}
public synchronized void run() {
// TODO Auto-generated method stub
while (flag ){
try {
wait();
} catch (InterruptedException e){
// TODO Auto-generated catch block
System. err.println(Thread.currentThread().getName()+"Exption...");
flag= false ;
}
System. err.println(Thread.currentThread().getName()+ "run...");
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
StopThread s= new StopThread();
Thread t= new Thread(s);
Thread t1= new Thread(s);
t.start();
t1.start();
int num=0;
while (true ){
if (num++ ==60){
// s.changflag();
t.interrupt(); //中断线程t冻结状态。
t1.interrupt(); //中断线程t1冻结状态。
break ;
}
System. err.println(Thread. currentThread().getName()+num);
}
System. err.println( "over" );
}
}
九 守护线程
守护线程与普通线程写法上基本么啥区别,调用线程对象的方法setDaemon(true),则可以将其设置为守护线程。
class MyCommon extends Thread {
public void run() {
for (int i = 0; i < 5; i++){
System.out.println("前台线程第" + i + "次执行!");
try {
Thread.sleep(7);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
class MyDaemon implements Runnable {
public void run() {
for (int i = 0; i < 100;i++) {
System.out.println("后台线程第" + i+ "次执行!");
try {
Thread.sleep(7);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
public class Test1 {
public static void main(String[] args) {
Thread t1 = new MyCommon();
Thread t2 = new Thread(newMyDaemon());
t2.setDaemon(true); //设置为守护线程
t2.start();
t1.start();
}
}
前台线程是保证执行完毕的,后台线程还没有执行完毕就退出了。
注意:JRE判断程序是否执行结束的标准是所有的前台执线程行完毕了,而不管后台线程的状态。
十 其他方法
1.join方法;
抢夺cpu资源或者临时加入线程执行。
当A线程执行到B线程时,遇到join方法,A线程就会等待,等B线程执行完毕后A才会执行。
另外,join()方法还有带超时限制的重载版本。例如t.join(5000);则让线程等待5000毫秒,如果超过这个时间,则停止等待,变为可运行状态。
2.线程优先级
setPriority(int newPriority)更改线程的优先级。
getPriority()获取当前线程的优先级。
每个线程都会有自己的优先级,JVM对优先级的处理方式是“抢占式”的。当JVM发现优先级高的线程时,可能会优先运行该线程;对于多个优先级相等的线程,JVM对其进行轮询处理。
Java的线程优先级从1到10,默认是5,Thread类定义了2个常量:MIN_PRIORITY NORM_PRIORITY和MAX_PRIORITY来表示最低、默认和最高优先级。
注意:当设计多线程应用程序的时候,一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的,只能把线程优先级作用作为一种提高程序效率的方法,但是要保证程序不依赖这种操作。
3.yield()方法
Thread.yield()方法作用是:暂停当前正在执行的线程对象,并执行其他线程。
yield()应该做的是让当前运行线程回到可运行状态,以允许具有相同优先级的其他线程获得运行机会。因此,使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是,实际中无法保证yield()达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。
因此yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下,yield()将导致线程从运行状态转到可运行状态,但有可能没有效果。
4.线程睡眠
A:线程睡眠是帮助所有线程获得运行机会的最好方法。
B:线程睡眠到期自动苏醒,并返回到可运行状态,不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此,sleep()方法不能保证该线程睡眠到期后就开始执行。
C:sleep()是静态方法,只能控制当前正在运行的线程。