黑马程序员--多线程

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

陈宝强

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

阅读量247

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/u011464506/article/details/9501413

版权

java基础专栏收录该内容

2 篇文章 0 订阅

订阅专栏

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

一、概述

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

线程：就是进程中的一个独立的控制单元

线程在控制着进程的执行，一个进程中至少有一个线程

JVM启动的时候会有一个进程java.exe,该进程中至少有一个进程负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程陈为主线程

扩展：其实更细节说明JVM，JVM启动不止一个线程，还有负责垃圾回收机制的线程

1.如何在自定义的代码中，自定义一个线程呢？

通过api的查找，java已经提供了对线程这类事物的描述，就是Thread类，

创建线程的第一种方式：

步骤：1.定义类继承Thread类

2.覆写Thread类中的run方法

3.调用线程的start方法（该方法有俩作用：启动线程，调用run方法）

class Test extends Thread
{
	 Test(String name)
	{
		super(name);
	}
	 public void run()
	 {    
		 for(int x=0;x<50;x++)
		 {
		 System.out.println(/*Thread.currentThread()*/this.getName()+"..run..."+x);//获取当前线程对象的名称
	     }
	 }
}
public class ThreadDemo1
{
	public static void main(String[] args)
	{
		Test t1 = new Test("one");//创建一个线程并赋名称
		Test t2 = new Test("two");
		t1.start();//有俩作用  启动线程  调用run方法
		t2.start();
		for(int x=0;x<50;x++)
		{ 
			System.out.println("hello world");
		}
	}
}

运行特点：

A.并发性：我们看到的程序（或线程）并发执行，其实是一种假象。有一点需要明确：；在某一时刻，只有一个程序在运行（多核除外），此时cpu是在进行快速的切换，以达到看上去是同时运行的效果。由于切换时间是非常短的，所以我们可以认为是在并发进行。

B.随机性：在运行时，每次的结果不同。由于多个线程都在获取cpu的执行权，cpu执行到哪个线程，哪个线程就会执行。可以将多线程运行的行为形象的称为互相抢夺cpu的执行权。这就是多线程的特点，随机性。执行到哪个程序并不确定。

为什幺覆盖run方法？

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

/*创建线程的另一只种方法：实现Runnable接口
 * 步骤:1.定义类实现Runnable接口
 * 2.覆盖Runnable接口中方法
 * 3.通过Thread类建立线程对象  有几个线程就建立几个对象
 * 4.通过Runnablejie接口的子类对象作为实际参数传递给Thread类的构造函数
 * 为什么将Runnablejie接口的子类对象作为实际参数传递给Thread类的构造函数？
 * 因为自定义的run方法所属对象是Runnable接口的子类对象，所以要让线程去指定对象的run方法，就必须明确该run方法所属对象
 * */
/*实现方式与继承方式有何区别：

1、实现方式：避免了单继承的局限性。

             在定义线程时，建议使用实现方式。

2区别：

继承Thread：线程代码存放在Thread子类的run方法中。

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

需要注意的是：局部变量在每一个线程中都独有一份*/



class Ticket implements Runnable
{
	private int tick =100;
	Object obj = new Object();
 	public void run()
	{
		while(true)
		{
			synchronized(obj)
			{
				if(tick >0)
				{
					try{Thread.sleep(10);}//此处10的单位是毫秒
					catch(Exception e){}
					System.out.println(Thread.currentThread().getName()+"..sale.."+tick--);
				}
			}
		}
	}
}
public class ThreadDemo2 
{
	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();
	}
}


/*同步代码快
   synchronized()
   {
   	需要被同步的代码
   }
   
   同步的前提
   1.必须有两个或两个以上的线程
   2.必须是多个线程使用一把锁
   3.必须是保证同步中只能有一个线程在运行
   好处；解决了多线程的安全问题
 弊端;多个线程都需要判断锁，消耗资源
   */

线程的运行状态

线程运行状态可用如下图示说明：

需要说明的是：

A.阻塞状态：具备运行资格，但是没有执行权，必须等到cpu的执行权，才转到运行状态，。

B.冻结状态：放弃了cpu的执行资格，cpu不会将执行权分配给这个状态下的线程，必须被唤醒后，此线程要先转换到阻塞状态，等待cpu的执行权后，才有机会被执行到。

二、同步函数中的锁

1.非静态同步函数中的锁

函数续杯对象所调用，那么函数都有一个所属的对象引用，就是this,因此同步函数使用的锁为this。

package ThreadDemo;

class Sale implements Runnable  
{  
    private int tick = 100;  
    boolean flog = true;  
    public void run()  
    {  
        if (flog)  
        {  
            //线程一执行   
            while(true)  
            {  
                //如果对象为obj，则是两个锁，是不安全的；换成this，为一个锁，会安全很多   
                synchronized(this)  
                {  
                    if (tick > 0)
                    {   try{Thread.sleep(10);}catch(Exception e){}
                        System.out.println(Thread.currentThread().getName() + "--code--:" + tick--);  
                    }
                 }  
              }  
          }
    
        //线程二执行   
        else  
            while(true)  
                show();  
    }  

    public synchronized void show()  
    {  
        if (tick > 0)  
        {	 
        	try{Thread.sleep(10);}catch(Exception e){}
            System.out.println(Thread.currentThread().getName() + "----show-----:" + tick--);  
    
        }
     }  
}  
  
class ThreadDemo4  
{  
    public static void main(String[] args)   
    {  
        Sale t = new Sale();  
        Thread t1 = new Thread(t);//创建一个线程   
        Thread t2 = new Thread(t);//创建一个线程   
        t1.start();  
        try{Thread.sleep(10);}catch(Exception e){}//关闭主线程，运行t1
        t.flog = false;//开启线程一，即关闭if，让线程二执行else中语句   
        t2.start();  
    }
}

2.静态同步函数中的锁

如果同步函数被静态修饰后，经验证，使用的锁不是thisl了，因为静态方法中不可定义this,所以，这个锁不再是this了。静态进内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象：类名.class ;该对象的类型是class

所以静态的同步方法使用的锁是该方法所在的字节码文件对象，即类名.class

package ThreadDemo;
import java.util.concurrent.locks.*;  


//线程间通信  唤醒机制  生产者消费者  3个
public class ThreadDemo6 {

	public static void main(String[] args){  
        Resouse r = new Resouse();  
        Producer p = new Producer(r);  
        Consumer c = new Consumer(r);  
        Thread t1 = new Thread(p);  
        Thread t2 = new Thread(c);  
        Thread t3 = new Thread(p);  
        Thread t4 = new Thread(c);  
        t1.start();  
        t2.start();  
        t3.start();  
        t4.start();  
    }  
}  
  
class Resouse{  
    private String name;  
    private int count = 1;  
    private boolean flag =  false;   
    private Lock lock = new ReentrantLock();  
    private Condition condition_P = lock.newCondition();  
    private Condition condition_C = lock.newCondition();  
//要唤醒全部，否则都可能处于冻结状态，那么程序就会停止。这和死锁有区别的。   
    public void set(String name)throws InterruptedException{  
        lock.lock();  
        try{  
            while(flag)//循环判断，防止都冻结状态   
                condition_P.await();  
            this.name = name + "--" + count++;  
            System.out.println(Thread.currentThread().getName() + "..生成者--" + this.name);  
            flag = true;  
            condition_C.signal();  
        }finally{  
            lock.unlock();//释放锁的机制一定要执行   
        }         
    }  
    public void out()throws InterruptedException{  
        lock.lock();  
        try{  
            while(!flag)//循环判断，防止都冻结状态   
                condition_C.await();  
            System.out.println(Thread.currentThread().getName() + "..消费者." + this.name);  
            flag = false;  
            condition_P.signal();//唤醒全部   
        }finally{  
            lock.unlock();  
        }  
    }  
}  
  
class Producer implements Runnable{  
    private Resouse r;  
    Producer(Resouse r){  
        this.r = r;  
    }  
    public void run(){  
        while(true){  
            try{  
                r.set("--商品--");  
            }catch (InterruptedException e){}  
        }  
    }  
}  
  
class Consumer implements Runnable{  
    private Resouse r;  
    Consumer(Resouse r){  
        this.r = r;  
    }  
    public void run(){  
        while(true){  
            try{  
                r.out();  
            }catch (InterruptedException e){}  
        }  
    }  
}  
/*等待唤醒机制：

1、显式锁机制和等待唤醒机制：

在JDK 1.5中，提供了改进synchronized的升级解决方案。将同步synchronized替换为显式的Lock操作，将Object中的wait，notify，notifyAll替换成Condition对象，该对象可对Lock锁进行获取。这就实现了本方唤醒对方的操作。在这里说明几点：

1）、对于wait，notify和notifyAll这些方法都是用在同步中，也就是等待唤醒机制，这是因为要对持有监视器（锁）的线程操作。所以要使用在同步中，因为只有同步才具有锁。

2）、而这些方法都定义在Object中，是因为这些方法操作同步中的线程时，都必须表示自己所操作的线程的锁，就是说，等待和唤醒的必须是同一把锁。不可对不同锁中的线程进行唤醒。所以这就使得程序是不良的，因此，通过对锁机制的改良，使得程序得到优化。

3）、等待唤醒机制中，等待的线程处于冻结状态，是被放在线程池中，线程池中的线程已经放弃了执行资格，需要被唤醒后，才有被执行的资格。

2、对于上面的程序，有两点要说明：

1）、为何定义while判断标记：

原因是让被唤醒的线程再判断一次。

避免未经判断，线程不知是否应该执行，就执行本方的上一个已经执行的语句。如果用if，消费者在等着，两个生成着一起判断完flag后，cpu切换到其中一个如t1，另一个t3在wait，当t1唤醒冻结中的一个，是t3（因为它先被冻结的，就会先被唤醒），所以t3未经判断，又生产了一个。而没消费。


2）这里使用的是signal方法，而不是signalAll方法。是因为通过Condition的两个对象，分别唤醒对方，这就体现了Lock锁机制的灵活性。可以通过Contidition对象调用Lock接口中的方法，就可以保证多线程间通信的流畅性了。


 * */

这简单介绍几个Thread中的方法：

1、停止线程：

在java 1.5之后，就不再使用stop方法停止线程了。那么该如何停止线程呢？只有一种方法，就是让run方法结束。

开启多线程运行，运行代码通常为循环结构，只要控制住循环，就可以让run方法结束，也就可以使线程结束。

注：

特殊情况：当线程处于冻结状态，就不会读取标记，那么线程就不会结束。

interrupt()。

此方法是为了让线程中断，但是并没有结束运行，让线程恢复到运行状态，再判断标记从而停止循环，run方法结束，线程结束。

2、守护线程：---setDaemon()

可将一个线程标记为守护线程，直接调用这个方法。此方法需要在启动前调用守护线程在这个线程结束后，会自动结束，则Jvm虚拟机也结束运行。

3、临时加入线程：--join()

特点：当A线程执行到B线程方法时，A线程就会等待，B线程都执行完，A才会执行。join可用来临时加入线程执行。

4、优先级：

setPriority()：

在Thread中，存在着1~10这十个执行级别，最高的是 MAX_PRIORITY 为10，最低是 MIN_PRIORITY 为1，默认优先级是 NORM_PRIORITY 为5；但是并不是优先级越高，就会一直执行这个线程，只是说会优先执行到这个线程，此后还是有其他线程会和此线程抢夺cpu执行权的。

优先级是可以设定的，可通过setPriority()设定，如：setPriority(Thread.MAX_PRIORITY)设优先级为最大。

yield()：

此方法可暂停当前线程，而执行其他线程。通过这个方法，可稍微减少线程执行频率，达到线程都有机会平均被执行的效果

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