多线程基础

最新推荐文章于 2021-03-23 22:37:31 发布

爪蛙爱踢程序猿

最新推荐文章于 2021-03-23 22:37:31 发布

阅读量284

点赞数

分类专栏： jse 文章标签：多线程

本文链接：https://blog.csdn.net/u013992890/article/details/39852989

版权

jse 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.进程与线程的区别

进程是cpu执行的一个可执行程序，cpu通过进程间的快速切换实现了让所有的程序看似都同时在运行（单核）

线程是进程的执行流程，一个进程中至少有一个线程，每个线程可以得到一小段的执行时间（像时间片轮转法）

执行完这个事务就去执行下一个事务，这样使得一个程序看起来可以同时处理多个事务

2.线程栈模型

线程以栈的形式存储，main方法创建的时候会开启一个主线程，即开启了一个栈，当创建一个线程的时候，使用.start()方法的

时候，再创建一个执行栈，两个栈同时运行，就形成了多线程。

3.开启线程的两种方法

实现Runnable接口，覆盖run方法（推荐）

继承Thread类，覆盖run方法

两种方法的区别：Runnable避免了单继承的局限性

4.线程状态转换

创建-就绪-执行-阻塞-死亡

5.sleep方法

<span style="font-size:14px;"><strong>package Myday3;
/** 
* 一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串 
*/
public class MyThread implements Runnable {

    @Override
	public void run() {
		for(int i=0;i<101;i++){
			if(i!=0&&i%10==0)
			System.out.println("输出");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(i);
		}
		
	}
	
    public static void main(String[] args) {
		MyThread mt = new MyThread();
		Thread t1 = new Thread(mt);
		t1.start();

	}
}
</strong></span>

6.线程的优先级和线程让步

线程的优先级在（1--》10）通过Thread.getPriority()实现，例如

Thread t= new Thread();

t.setPriority(10);

t.start();

线程让步是通过Thread.yield()方法实现的，作用：暂停当前线程让其他线程执行

不管是线程优先级还是线程让步都无法真正完全控制住线程，被让步和低优先级的线程仍然有机会被执行到

7.join（）方法

Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作。例如：

        Thread t = new MyThread();
        t.start();
        t.join();

另外，join()方法还有带超时限制的重载版本。例如t.join(5000);则让线程等待5000毫秒，如果超过这个时间，则停止等待，变为可运行状态。

join（）方法可以保证当前的线程停止，让其他线程先执行，如若其他线程死亡，不暂停该线程

8.同步

同步的前提：必须有多个线程，多个线程必须使用同一个锁，同步中必须只有一个线程运行

好处：解决多线程的安全问题，弊端：每次都得判断锁，消耗资源

同步方法：同步代码块，同步函数，锁默认为this，静态为ClassName.class

9.死锁

产生原因：同步嵌套同步，且锁不一样

class Test implements Runnable
{
	private boolean flag;
	Test(boolean flag)
	{
		this.flag=flag;
	}

	public void run()
	{
		if(flag)
		{
			synchronized(Mylock.locka)
			{
				System.out.println("if locka");
				synchronized(Mylock.lockb)
				{
					System.out.println("if lockb");
				}
			}
		}
		else
		{
			synchronized(Mylock.lockb)
			{
				System.out.println("else lockb");
				synchronized(Mylock.locka)
				{
					System.out.println("else locka");
				}
			}
		}

	}
}

class Mylock
{
	static Object locka=new Object();
	static Object lockb=new Object();
}


class  DeadLockTest
{
	public static void main(String[] args) 
	{
		Thread t1=new Thread(new Test(true));
		Thread t2=new Thread(new Test(false));
		t1.start();
		t2.start();
	}
}

10.多线程之间的通信

wait(),notify(),notifyAll() 都使用在同步中，
因为要对持有锁的线程进行操作，也只有同步中有锁

这些方法定义在Object中，因为每一个对象均可以为锁
等待和唤醒的必须是同一把锁
只有一个生产者和一个消费者的时候
使用If(flag)，notify();
生产者和消费者模型注意flag
注意while(flag),notifyAll();

生产者消费者模型

一个生产者和一个消费者

package day4;

class Resource
{
	private String name;
	private int count=1;
	private boolean flag=false;

	public synchronized void set(String name)
	{
		while(flag)
			try{wait();}//使用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();}//使用wait会抛异常
			catch(Exception e){}
		System.out.println(Thread.currentThread().getName()+"..消费者"+this.name);
		flag=false;
		this.notifyAll();
	}
}


class Produce implements Runnable
{
	private Resource res;
	Produce(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.set("消费+");		
		}
	}
}

class PCDemo
{
	public static void main(String[] args) 
	{
		Resource r=new Resource();

		Produce pro=new Produce(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();

		System.out.println("Hello World!");
	}
}

多个生产者和多个消费者

<span style="font-size:14px;">package Myday3;

class Source{
	int count=0;
	private String name;
	boolean flag = false;
	public void set(){
			synchronized(this){
				while(flag)
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"生产"+(++count));
			    
				flag=true;
				this.notifyAll();				
		}
		
	}
	public void out(){
			synchronized(this){
				while(!flag)
					try {
						this.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				System.out.println(Thread.currentThread().getName()+"消费"+count);
				flag=false;
				this.notifyAll();
			}					
		}
	}

class Produce implements Runnable{
	private Source sr;
	Produce(Source sr){
		this.sr = sr;
	}
		
	public void run(){
		while(true)
		sr.set();
	}
}

class Consumer implements Runnable{
	private Source sr;
	Consumer(Source sr){
		this.sr = sr;
	}
	@Override
	public void run() {	
		while(true)
		sr.out();
	}
}

 class Lock {
	 public static void main(String[] args){
		 Source sr = new Source();
		 Produce pd1 = new Produce(sr);
		 Produce pd2 = new Produce(sr);
		 Consumer con1 = new Consumer(sr);
		 Consumer con2 = new Consumer(sr);
		 new Thread(pd1).start();
		 new Thread(pd2).start();
		 new Thread(con1).start();
		 new Thread(con2).start();
		 
	 }
}
</span>

jdk1.5提供了多线程的解决方案

将synchronized替换成了Lock

将wait notify notifyAll替换成了condition，该对象通过lock获得。

改进版

<span style="font-size:14px;">class Resource
{
	private String name;
	private int count=1;
	private boolean flag=false;

	private Lock lock=new ReentrantLock();//创建锁
	
	private Condition con_1=lock.newCondition();
	private Condition con_2=lock.newCondition();

	public  void set(String name)throws InterruptedException
	{
		lock.lock();
		try
		{	
			while(flag)
			con_1.await();
			
			this.name=name+"--"+count++;
			System.out.println(Thread.currentThread().getName()+"..生产者"+this.name);
			flag=true;
			con_2.signal();
		}

		finally
		{
			lock.unlock();
		}
		
	}

	public  void out()

	{	
		lock.lock();
		try
		{
			while(!flag)
				try {
					con_2.await();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			System.out.println(Thread.currentThread().getName()+"..消费者"+this.name);
		flag=false;
		con_1.signal();
		}
			finally
		{
			lock.unlock();
		}
	}
}


class Produce implements Runnable
{
	private Resource res;
	Produce(Resource res)
	{
		this.res=res;
	}

	public void run()
	{
		while(true)
		{
			try
			{
				res.set("商品+");
			}
			catch (InterruptedException e)
			{
			}
			
		}
	}

}


class Consumer implements Runnable
{
	private Resource res;
	Consumer(Resource res)
	{
		this.res=res;
	}

	public void run()
	{
		while(true)
		{
			try
			{
			res.set("消费+");
				
			}
			catch (InterruptedException e)
			{
			}
			
		}
	}

}





class  PCDemo
{
	public static void main(String[] args) 
	{
		Resource r=new Resource();

		Produce pro=new Produce(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();


		System.out.println("Hello World!");
	}
}
</span>

11.守护线程

public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
  该方法必须在启动线程前调用。

  该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。

12.停止线程

class StopThread implements Runnable
{
	private boolean flag=true;
	public void run()
	{
		while(flag )
		{	
			try{wait();}//使用wait会抛异常
			catch(InterruptedException e)
			{	
				System.out.println(Thread.currentThread().getName()/*.toString()*/+"...Exception");
			}
			System.out.println(Thread.currentThread().getName()+"...run");
		}
	}

	public void changeFlag()
	{
		flag=false;
	}
}

class  StopThreadDemo
{
	public static void main(String[] args) 
	{

		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");
	}
	
}