java多线程

最新推荐文章于 2024-07-10 21:31:13 发布

and-android

最新推荐文章于 2024-07-10 21:31:13 发布

阅读量628

点赞数

分类专栏： Java学习

本文链接：https://blog.csdn.net/u010773245/article/details/9285355

版权

Java学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

线程和进程的区别?
进程：正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。

线程：其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。

一个进程至少有一个线程在运行，当一个进程中出现多个线程时，就称这个应用程序是多线程应用程序，每个线程在栈区中都有自己的执行空间，自己的方法区、自己的变量。
jvm在启动的时，首先有一个主线程，负责程序的执行，调用的是main函数。主线程执行的代码都在main方法中。
当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。

线程随机性的原理?
线程是随机性的，因为CPU在不断地进行时间片的切换；

线程的状态：1》产生(new)：线程已经被创建，但是未被启动
            2》可执行(Runnable)：线程处于可执行状态，等待被执行
            3》死亡(Dead)：当一个线程正常结束时，便处于死亡状态
            4》停滞():当线程处于停滞状态时，不被程序调用
.多线程的安全问题是什么?涉及到的两个因素有什么?如何解决?
安全问题：当多条语句在操作同一个线程共享数据时，可能会发生一个线程对多条语句只执行了一部分还没有执行完，
         另一个线程参与进来执行，会导致共享数据的错误；
解决办法：对多条操作共享数据时，只能让一个线程都执行完，再让其他线程执行，java提供同步方式来解决线程的安全问题

同步的实现方面有两种，分别是synchronized,wait与notify
同步的原理：通过带锁的代码块将容易出现安全问题的代码进行封装
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

创建线程有哪两种方式?
有两种方式：1》继承Thread类；
   步骤：1>继承Thread类
         2>重写run方法
         3>创建Thread的子类对象(创建线程)
         4>start启动线程(两个动作启动线程并调用run方法)

<strong><span style="font-size:18px;">举例：
public class Tick extends Thread{//继承线程

	private static int tick = 60;//加static 设置售票窗口共有20张票
	
	public void run(){
		while(true){
		if(tick > 0){
			try {
				Thread.sleep(10);//延时
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("sal-->" + this.getName() + tick--);
		}
	}
  }
}
public class TickDemo {
	
	public static void main(String[] args) {
		
		Tick t = new Tick();//创建线程
		t.setName("1号窗口");//设置线程名称
		Tick t1 = new Tick();
		t1.setName("2号窗口");
		Tick t2 = new Tick();
		t2.setName("3号窗口");
		Tick t3 = new Tick();
		t3.setName("4号窗口");
		
		t.start();//启动线程
		t1.start();
		t2.start();
		t3.start();
		
	}

}</span></strong>

2》实现Runnable接口
步骤：1>实现Runnable接口
        2>重写run方法
3>创建Runnable子类对象
        4>创建Thread类对象(创建线程)，并将Runnable子类对象作为参数传递给Thread的构造函数
        5>调用Thread的start方法启动线程；

<strong><span style="font-size:18px;">举例：：
public class ThunderThread implements Runnable{

	public void run() {
		
		for(int i = 1; i <= 100; i++ ){
			try {
				Thread.sleep(150);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "已下载" + i +"%");
		if(i == 100){
			System.out.println(Thread.currentThread().getName() + "已下载完毕");
		}
		}
		
	}
}
public class Demo {
	
	public static void main(String[] args) throws InterruptedException {
		
		ThunderThread t = new ThunderThread();
		
		Thread t1 = new Thread(t);
		t1.setName("功夫熊猫");
		Thread t2 = new Thread(t);
		t2.setName("蜘蛛侠");
		Thread t3 = new Thread(t);
		t3.setName("世界末日");
		Thread t4 = new Thread(t);
		t4.setName("速度与激情");
		Thread t5 = new Thread(t);
		t5.setName("太囧");
		t1.setDaemon(true);//守护线程
		t1.start();
	}

}</span></strong>

同步死锁：通常只要将同步进行嵌套，就可以看到现象。同步函数中有同步代码块，同步代码块中还有同步函数。

<strong><span style="font-size:18px;">死锁：
public class Lock {
	//创建两把锁
	public static final Object locka = new Lock();
	public static final Object lockb = new Lock();	
}
public class Text implements Runnable{
	private boolean flag ;
	
	public Text(boolean flag){//有参构造
		this.flag = flag;
	}
	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");
				}
			}
		}
	}	
}
public class ThreadDemo {

	public static void main(String[] args) {
		//创建线程并启动
		new Thread(new Text(true)).start();
		new Thread(new Text(false)).start();
	}
}</span></strong>

为什么要有Runnable接口的出现？

1>：通过继承Thread类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承Thread类，因为java单继承的局限性。
可是该类中的还有部分代码需要被多个线程同时执行。这时怎么办呢？
只有对该类进行额外的功能扩展，java就提供了一个接口Runnable。这个接口中定义了run方法，其实run方法的定义就是为了存储多线程要运行的代码。
所以，通常创建线程都用第二种方式。
因为实现Runnable接口可以避免单继承的局限性。

2>：其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。为其他类进行功能扩展提供了前提。

所以Thread类在描述线程时，内部定义的run方法，也来自于Runnable接口。
实现Runnable接口可以避免单继承的局限性。而且，继承Thread，是可以对Thread类中的方法，进行子类复写的。但是不需要做这个复写动作的话，只为定义线程代码存放位置，实现
Runnable接口更方便一些。所以Runnable接口将线程要执行的任务封装成了对象。

多线程的安全问题是什么?涉及到的两个因素有什么?如何解决?
安全问题：当多条语句在操作同一个线程共享数据时，可能会发生一个线程对多条语句只执行了一部分还没有执行完，
另一个线程参与进来执行，会导致共享数据的错误；
解决办法：对多条操作共享数据时，只能让一个线程都执行完，再让其他线程执行，java提供同步方式来解决线程的安全问题

wait和sleep区别：分析这两个方法：从执行权和锁上来分析：
wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。
sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。
wait：线程会释放执行权，而且线程会释放锁。
Sleep：线程会释放执行权，但不是不释放锁。

同步的好处：解决了多线程的安全问题
弊端：多个线程需要判断锁，比较消耗资源；
同步的前提：1》至少有两个或两个以上线程；
2》多个线程必须使用同一把锁；
同步函数使用this锁；
当加了static后使用该方法所属类的字节码文件对象，即：类名.class

<strong><span style="font-size:18px;">同步锁：
public class Tick implements Runnable{
	
	private int tick = 2000;
	boolean flag = true;
	public void run() {
		if(flag){
		while(true){
			synchronized(this){
			if(tick > 0){
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("还剩" + tick + "张票");
				System.out.println(Thread.currentThread().getName() + "cod--->" + tick--);
			}
		 }
	   }
	
	}else{
		while(true){
			show();
		}
	}
  }
		public synchronized void show(){
		      
			if(tick > 0){
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("还剩" + tick + "张票");
				System.out.println(Thread.currentThread().getName() + "show--->" + tick--);
			}
	}
}

public class TickDemo {
	
	public static void main(String[] args) {
		Tick t = new Tick();
		Thread t1 = new Thread(t);
		t1.setName("1售票窗口");
		Thread t2 = new Thread(t);
		t2.setName("2售票窗口");
		t1.start();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t.flag = false;
		t2.start();				
	}

}</span></strong>

线程间通信：思路：多个线程在操作同一个资源，但是操作的动作却不一样。
1：将资源封装成对象。

2：将线程执行的任务(任务其实就是run方法。)也封装成对象。

等待唤醒机制：涉及的方法：

wait:将同步中的线程处于冻结状态。释放了执行权，释放了资格。同时将线程对象存储到线程池中。

notify：唤醒线程池中某一个等待线程。

notifyAll:唤醒的是线程池中的所有线程。

线程间的通信：

<strong><span style="font-size:18px;">资源类
public class Resource {
	
	private String name;
	private int id = 1;
	private boolean flag = false;
	
	public synchronized void set(String name){
		while(flag){
			try {
				this.wait();//睡眠
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.name = name + "---" + id++;//自动生成编号
		System.out.println(Thread.currentThread().getName() + "生产者 --》" + this.name);
		this.flag = true;
		this.notifyAll();//唤醒所有
	}
	
	
      public synchronized void out(){
	  while(!flag){//每次都判断
		  try {
			this.wait();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	  }
	  System.out.println(Thread.currentThread().getName() + "消费者----》" + name);
	  		this.flag = false;
	  		this.notifyAll();
      }

}
生产类
public class Producer implements Runnable {

	private Resource r;

	public Producer(Resource r) {
		this.r = r;
	}

	int x = 0;

	public void run() {
		for (int id = 0; id < 200; id++) {
			if (x == 0) {
				r.set("lili");
			} else {
				r.set("莉莉");
			}
			x = (x + 1) % 2;
		}
	}
}

消费类
public class Consumer implements Runnable{
	private Resource r;
	
	public Consumer(Resource r){
		this.r = r;
	}

	public void run() {
		for(int id = 0; id < 200; id++){
		r.out();
	}
    }
}
测试类
public class Demo {
	
	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();
	}

}</span></strong>