黑马程序员---回顾之java多线程技术

最新推荐文章于 2023-02-03 17:59:58 发布

u011937762

最新推荐文章于 2023-02-03 17:59:58 发布

阅读量578

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/djbup/article/details/14104489

版权

JAVA 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

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

1.多线程概述：

进程：正在进行中的程序(直译)。
线程：就是进程中一个负责程序执行的控制单元(执行路径)，一个进程中可以多执行路径，称之为多线程。一个进程中至少要有一个线程。
开启多个线程是为了同时运行多部分代码。每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务。

多线程好处：解决了多部分同时运行的问题。

多线程的弊端：线程太多回到效率的降低。

其实应用程序的执行都是cpu在做着快速的切换完成的，这个切换是随机的。 JVM启动时就启动了多个线程，至少有两个线程可以分析的出来。 1，执行main函数的线程，
该线程的任务代码都定义在main函数中。 2，负责垃圾回收的线程。

2.线程创建方法：

创建线程方式一：继承Thread类。
步骤：
1，定义一个类继承Thread类。 2，覆盖Thread类中的run方法。
3，直接创建Thread的子类对象创建线程。
4，调用start方法开启线程并调用线程的任务run方法执行。
可以通过Thread的getName获取线程的名称 Thread-编号(从0开始)
主线程的名字就是main。

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

class ThreadDemo2  {   
	public static void main(String[] args)   {  
	Demo d1 = new Demo("旺财"); 
  
	Demo d2 = new Demo("xiaoqiang"); 
  
	d1.start();//开启线程，调用run方法。    
  
	d2.start(); 
  
	System.out.println("over...."+Thread.currentThread().getName()); 
 
	} 

}

创建线程的第二种方式：实现Runnable接口

步骤：
1,定义类实现Runnable接口。
2，覆盖接口中的run方法，将线程的任务代码封装到run方法中。
3，通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。为什么？因为线程的任务都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务。 4，调用线程对象的start方法开启线程。
实现Runnable接口的好处：
1，将线程的任务从线程的子类中分离出来，进行了单独的封装。按照面向对象的思想将任务的封装成对象。 2，避免了java单继承的局限性。
所以，创建线程的第二种方式较为常用。

class Demo implements Runnable{
 public void run()  { 
  show(); 
 } 
 public void show()  { 
  for(int x=0; x<20; x++)   { 
   System.out.println(Thread.currentThread().getName()+"....."+x); 
 		}  
	}
}  
class  ThreadDemo { 
 public static void main(String[] args)   {  
   Demo d = new Demo(); 
  Thread t1 = new Thread(d);   
  Thread t2 = new Thread(d);   
  t1.start();   
  t2.start();  
	}
}

3.线程安全问题

线程安全问题产生的原因：
1，多个线程在操作共享的数据。
2，操作共享数据的线程代码有多条。
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算。就会导致线程安全问题的产生。
解决思路；
就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程时不可以参与运算的。
必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。在java中，利用同步代码块或同步方法，jdk5.0的lock就可以解决此类问题。
同步代码块的格式：
synchronized(对象) {
需要被同步的代码；
}
同步的好处：解决了线程的安全问题。
同步的弊端：相对降低了效率，因为同步外的线程的都会判断同步锁。同步的前提：同步中必须有多个线程并使用同一个锁。

静态的同步函数使用的锁是该函数所属字节码文件对象，

可以用 getClass方法获取，也可以用当前类名.class 表示。

同步函数的使用的锁是this；

同步函数和同步代码块的区别：

同步函数的锁是固定的this，同步代码块的锁是任意的对象。建议使用同步代码块。

案例：

多线程典型案例之银行存钱

/*
 *   需求:储户，两个，每个都到银行存钱每次存100，，共存三次。 
 */  
class Bank { 
 private int sum; 
//  private Object obj = new Object();  
// 同步函数  
public synchronized void add(int num){ 
	 sum = sum + num;  
  	 try{Thread.sleep(10);}catch(InterruptedException e){}   
	 System.out.println("sum="+sum); 
	 } 
}  
class Cus implements Runnable { 
 private Bank b = new Bank();  
 public void run()  { 
  for(int x=0; x<3; x++)   { 
   b.add(100);   
		} 
	 } 
}  
class BankDemo  { 
 public static void main(String[] args)   { 
  Cus c = new Cus(); 
  Thread t1 = new Thread(c);   
	Thread t2 = new Thread(c);  
	 t1.start();   
	t2.start();  
	} 
}

4.死锁

产生情况：同步里面还有同步而且用的不同的锁

典型死锁案例之同步代码块嵌套

package cn.djb.thread;

public class DeadLockTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		A a1=new A(false);
		A a2=new A(true);

		Thread t1=new Thread(a1);
		Thread t2=new Thread(a2);
	
		
		t1.start();
		
		t2.start();
	
	}

}
class A implements Runnable{
	private boolean flag;
	public A(boolean b){
		this.flag=b;
	}
	public void run() {
		if(flag){
		synchronized (Lock.locka) {
	
			System.out.println("if locka");
			synchronized (Lock.lockb) {
				System.out.println("if lockb");
			}
			}
		}
		else{
			synchronized (Lock.lockb) {
				System.out.println("else lockb");
				synchronized (Lock.locka) {
					System.out.println("else locka");
				}
				}
		}
		}
		
		
	}


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

5.多线程下的单例（懒汉式）

package cn.djb.single;

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

6.线程等待唤醒机制：

线程状态图：

wait() 释放执行资格，线程处于等待状态

notify() 唤醒对方第一个处于等待状态的线程

notifyAll() 唤醒对方所有处于等待状态的线程

案例：

package cn.djb.thread;
/*
 * 要求：给一个对象设置一个人名和性别，然后才可以取走，取走后才可以再设置，如此交替
 */
public class WaitNotifyTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Res r = new Res();
		Input in = new Input(r);
		Output out = new Output(r);
		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);
		t1.start();
		t2.start();

	}

}

class Res {
	private String name;
	private String sex;
	private boolean s;

	public boolean isS() {
		return s;
	}

	public void setS(boolean s) {
		this.s = s;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

}

class Input implements Runnable {
	private Res r;
	private boolean b;

	public Input(Res r) {
		this.r = r;
	}

	public void run() {
		for (int i = 0; i < 1000; i++) {
			synchronized (r) {
				if (r.isS())
					try {
						r.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				if (b) {
					r.setName("张三");
					r.setSex("男");
					this.b = false;
				} else {
					r.setName("lili");
					r.setSex("female");
					this.b = true;
				}
				r.setS(true);
				r.notify();
			}
		}

	}

}

class Output implements Runnable {
	private int num;
	private Res r;

	public Output(Res r) {
		this.r = r;
	}

	public void run() {
		for (int i = 0; i < 1000; i++) {
			synchronized (r) {
				if (r.isS()) {
					System.out.println(r.getName() + "=" + r.getSex());
					num++;
					r.setS(false);
					r.notify();
				} else {
					try {
						r.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}

			}
			if (i == 999)
				System.out.println(num);
		}

	}

}

多生产者与多消费者案例：

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

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

	}
}

/*
对于多个生产者和消费者。
为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。


为什么定义notifyAll，
因为需要唤醒对方线程。
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。

*/


class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
			//  t1    t2
	public synchronized void set(String name)
	{
		while(flag)
			try{this.wait();}catch(Exception e){}//t1(放弃资格)  t2(获取资格)
		this.name = name+"--"+count++;

		System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
		flag = true;
		this.notifyAll();
	}


	//  t3   t4  
	public synchronized void out()
	{
		while(!flag)
			try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
		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();
		}
	}
}

JDK5.0升级版多生产者与消费者lock锁：

jdk1.5以后将同步和锁封装成了对象。并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作。
Lock接口：出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成现实锁操作。同时更为灵活。可以一个锁上加上多组监视器。 lock():获取锁。
unlock():释放锁，通常需要定义finally代码块中。
Condition接口：出现替代了Object中的wait notify notifyAll方法。将这些监视器方法单独进行了封装，变成Condition监视器对象。可以任意锁进行组合。

await(); signal(); signalAll();

package cn.djb.thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadLockTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Resource r=new Resource();
		Productor p=new Productor(r);
		Customer c=new Customer(r);
		Thread t1=new Thread(p);
		Thread t2=new Thread(p);
		Thread t3=new Thread(c);
		Thread t4=new Thread(c);
		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}
	

}

class Resource{
	private String name;
	private int  number=0;
	private boolean flag;
	private Lock lock=new ReentrantLock();
	private Condition condition_pro=lock.newCondition();
	private Condition condition_cus=lock.newCondition();
	public void sale() {
		lock.lock();
		try{
		while(!flag)
			condition_cus.await();
		System.out.println(Thread.currentThread().getName()+"............"+"sale"+name+number);
		flag=false;
		condition_pro.signal();
		}catch (Exception e) {
			
		}finally{
			lock.unlock();
		}
	}
	public void product(String name) {
		lock.lock();
		try{
		while(flag)
			condition_pro.await();
		this.name = name;
		this.number++;
		System.out.println(Thread.currentThread().getName()+"..."+"product"+this.name+this.number);
		flag=true;
		condition_cus.signal();
		}catch (Exception e) {
			
		}
		finally{
			lock.unlock();
		}
		
	}

}
class Productor implements Runnable{
	private Resource r;
	public Productor(Resource r){
		this.r=r;
	}
	public void run() {
		for(int i=0;i<600;i++)
		r.product("北京烤鸭");
	}
	
}
class Customer implements Runnable{
	private Resource r;
	public Customer(Resource r){
		this.r=r;
	}
	public void run() {
		for(int i=0;i<600;i++)
		r.sale();
	}
	
}

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

u011937762

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员---回顾之java多线程技术

1.多线程概述：进程：正在进行中的程序(直译)。线程：就是进程中一个负责程序执行的控制单元(执行路径)，一个进程中可以多执行路径，称之为多线程。一个进程中至少要有一个线程。开启多个线程是为了同时运行多部分代码。每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务。多线程好处：解决了多部分同时运行的问题。多线程的弊端：线程太多回到效率的降低。其实应用
复制链接

扫一扫