黑马程序员——Java语言--多线程

最新推荐文章于 2015-12-07 14:27:34 发布

迷途小码农~

最新推荐文章于 2015-12-07 14:27:34 发布

阅读量617

点赞数 1

分类专栏：黑马程序员文章标签： Java语言黑马程序员多线程线程

本文链接：https://blog.csdn.net/u013091087/article/details/49251895

版权

黑马程序员专栏收录该内容

6 篇文章 0 订阅

订阅专栏

———–android培训、java培训、java学习型技术博客、期待与您交流！————

概述

首先先了解一下进程，进程：正在进行中的程序。（直译）

线程：就是进程中一个负责程序执行的控制单元（执行路径），一个进程中可以有多个执行路径，称之为——多线程。

一个进程中至少有一个线程。

开启多个线程是为了同时运行多部分代码，每一个线程都有自己运行的内容，这个内容可以称为线程要执行的任务。

线程的状态

多线程的好处与弊端

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

弊端：线程太多会导致效率的降低。

其实应用程序的执行都是cpu在作者高速的切换完成的，这个切换是随机的。

多线程的创建方式

方式一：继承Thread类

步骤：

定义一个类继承Thread类。
覆盖Thread类中的run方法。
直接创建Thread的子类对象创建线程。
调用start方法开启线程并调用线程的任务run方法执行。

创建线程的目的

是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行。而运行的指定代码就是这个执行路径的任务。

JVM创建的主线程的任务都定义在了主函数中，而自定义的线程它的任务在哪儿呢？

Thread类用于描述线程，线程是需要任务的。所以Thread类也要对任务的描述。

这个任务就通过Thread类中的run方法来体现，也就是说，run方法就是封装自定义线程运行任务的函数。

开启线程是为了运行指定代码，所以只有继承Thread类，并覆写run方法。将运行的代码定义在run方法中即可。

Demo

class Demo extends Thread
{
	private String name;

	Demo(String name)
	{
		this.name = name;
	}

	// 覆盖run方法
	public void run()
	{
		for(int x=0; x<10; x++)
		{
			System.out.println(name+" - x = " + x);
		}
	}
}

class ThreadDemo 
{
	public static void main(String[] args) 
	{
		Demo d1 = new Demo("哈哈");
		Demo d2 = new Demo("小强");
		d1.start(); // 开启线程并调用run方法
		d2.start();
	}
}

可以通过Thread的getName()获取线程的名称 Thread-编号（从0开始），主线程的名字就是main

class Demo extends Thread
{
	private String name;

	Demo(String name)
	{
		// super(name); 这里可以修改线程的名称
		this.name = name;
	}

	// 覆盖run方法
	public void run()
	{
		for(int x=0; x<10; x++)
		{
			System.out.println(name+" - x = " + x + "-" + Thread.currentThread().getName());
		}
	}
}

class ThreadDemo 
{
	public static void main(String[] args) 
	{
		Demo d1 = new Demo("哈哈");
		Demo d2 = new Demo("小强");
		d1.start(); // 开启线程并调用run方法
		d2.start();
	}
}

多线程运行图解

方式二：实现Runnable接口

步骤：

定义类实现Runnable接口
覆盖接口中的run方法，将线程的任务代码封装到run方法中
通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递，为什么呢？因为线程的任务都封装在Runnable接口子类对象的run方法中，所以要在线程对象创建时就必须明确要运行的任务。如果不传递Runable子类对象，那么执行的就是Thread自己的run方法里的内容。
调用线程对象的start()方法开启线程并执行run方法。

Demo

class Demo implements Runnable // 如果Demo类已继承其他类（非Thread类），那么可以通过接口形式来完成
{
	public void run()
	{
		show();
	}

	public void show()
	{
		for(int x=0; x<10; 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();
	}
}

实现Runnable接口的好处：

将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成了对象。
避免了Java单继承的局限性。

所以，创建线程的第二种方式较为常用。

售票例子

/**
 * 需求：卖票。
 * 开启四个窗口进行售票，一共有100张票。
 */

class Ticket implements Runnable
{
	private int num = 100;
	public void run()
	{
		sale();
	}

	public void sale()
	{
		while(num > 0)
		{
			System.out.println(Thread.currentThread().getName() + "...ticket..." + num--);
		}
	}

}

class TicketDemo 
{
	public static void main(String[] args) 
	{
		// 四个窗口共用一个Runnable的子类对象
		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();
										
	}
}

图解

以上的例子存在着线程安全隐患问题，有可能打印出错号票！

线程安全问题产生的原因

1、多个线程在操作共享的数据。

2、操作共享数据的线程代码有多条。

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。

比如上面的例子，在判断了之后，切换到了另一个线程也判断通过了，在前面已通过的线程打印之后num就改变了，此时其他通过的线程可以使用到的num就是非法的了。

线程安全问题的解决思路——同步代码块（synchronized）

解决思路：就是将多条操作共享数据的线程代码进行封装起来，当有线程在执行这些代码的时候，其他线程就不可以参与运算。

必须要当前线程把这些需要操作共享数据的代码执行完成之后，其他线程才可以参与运算。

在Java中，用同步代码块就可以解决这个问题。

同步代码块的格式：

synchronzied(对象)

{

需要被同步的代码;

}

同步的好处：就是解决了线程安全问题。

同步的弊端：相对降低了效率，因为同步外的线程的都会判断同步锁。

同步的前提：同步中必须有多个线程并使用同一个锁，否则可能还会有问题。

对上面的售票例子通过同步代码块来解决

/**
 * 需求：卖票。
 * 开启四个窗口进行售票，一共有100张票。
 */

class Ticket implements Runnable
{
	private int num = 100;
	Object obj = new Object();

	public void run()
	{
		sale();
	}

	public void sale()
	{
		while(true)
		{
			// 使用同步代码块，obj相当于一个锁
			synchronized(obj)
			{	
				//这里让线程睡眠10毫秒，是想看到打印错票的情况
				try
				{
					Thread.sleep(10);
				}
				catch (InterruptedException e)
				{
					e.printStackTrace();
				}
				if(num > 0)
					System.out.println(Thread.currentThread().getName() + "...ticket..." + num--);
			}
		}
	}

}

class TicketDemo 
{
	public static void main(String[] args) 
	{
		// 四个窗口共用一个Runnable的子类对象
		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();
										
	}
}

同步函数

/**
 * 需求：储户，两个。每个都到银行存钱，每次存100块，共存三次。
 */

class Bank
{
	private int sum;
	// private Object obj = new Object(); // 锁
	// 将synchronized作为函数的修饰符使用，同步函数
	public synchronized void add(int num)
	{
		//synchronized(obj)
		//{
			sum += num;
			// 如果不使用同步，那么在这会有安全隐患
			//try
			//{
			//	Thread.sleep(10);
			//}
			//catch (InterruptedException e)
			//{
			//	e.printStackTrace();
			//}
			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();
	}
}

同步函数使用的锁是：this。

同步函数和同步代码块的区别：同步函数的锁是固定的this。同步代码块的锁是任意的对象。

建议使用同步代码块。

静态的同步函数使用的锁是该函数所属字节码文件对象，可以用getClass方法获取，也可以用当前类名.class表示。

单例模式涉及的多线程问题

//饿汉式
class Single
{
	private static final Single s = new Single();
	private Single(){}

	public static Single getInstance()
	{
		return s;
	}
}

//懒汉式
class Single
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)
			{
				if(s==null)
					s = new Single();
			}
		}
		return s;
	}
}

死锁示例：

一般嵌套同步代码块出现这个问题，开发中不常用，但是要避免这样的问题。

class Demo implements Runnable
{
	public boolean flag;
	Demo(boolean flag)
	{
		this.flag = flag;
	}

	public void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(MyLock.locka)
				{
					System.out.println(Thread.currentThread().getName() + "  if locka.....");
					synchronized(MyLock.lockb)
					{
						System.out.println(Thread.currentThread().getName() + "  if lockb.....");
					}
				}
			}
		}else
		{
			while(true)
			{
				synchronized(MyLock.lockb)
				{
					System.out.println(Thread.currentThread().getName() + "  else lockb.....");
					synchronized(MyLock.locka)
					{
						System.out.println(Thread.currentThread().getName() + "  else locka.....");
					}
				}
			}
		}
	}
}

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

class DeadLockDemo 
{
	public static void main(String[] args) 
	{
		Demo d1 = new Demo(false);
		Demo d2 = new Demo(true);
		Thread t1 = new Thread(d1);
		Thread t2 = new Thread(d2);
		t1.start();
		t2.start();
	}
}

线程间通信

示例

实现两个线程之间的通信，一个线程负责给资源添加数据，另一个线程在资源那获取数据。

class Resource
{
	String name;
	String sex;
}

class Input implements Runnable
{

	// 接收操作的资源的地址
	private Resource r;
	Input(Resource r)
	{
		this.r = r;
	}

	public void run()
	{
		boolean flag = true;
		while(true)
		{
			// 加上同步，是因为可能赋值赋到给name的时候
			//线程就切换到了输出了，那么sex还没有赋值，这就会出现name和sex不对应的错误
			synchronized(r)
			{
				if(flag)
				{
					r.name = "hazy";
					r.sex = "boy";
					flag = false;
				}
				else
				{
					r.name = "小赖";
					r.sex = "女女女女女女";
					flag = true;
				}	
			}
		}
	}
}

class Output implements Runnable
{
	// 接收操作的资源的地址
	private Resource r;
	Output(Resource r)
	{
		this.r = r;
	}

	public void run()
	{
		while(true)
		{
			// 因为资源类是唯一的，并且输入和输出操作的是同一个资源对象，那么可以作为同步锁
			synchronized(r)
			{
				System.out.println(r.name + " ...... " + r.sex);
			}
		}
	}

}

class ResourceDemo 
{
	public static void main(String[] args) 
	{
		// 创建资源
		Resource r = new Resource();
		// 创建任务
		Input in = new Input(r);
		Output out = new Output(r);
		// 创建线程，执行路径。
		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);
		// 开启线程
		t1.start();
		t2.start();
	}
}

等待唤醒机制

涉及的方法：

wait()：让线程处于冻结状态，被wait的线程会被存储在线程池中。
notify()：唤醒线程池中的一个线程（任意）。
notifyAll()：唤醒线程池中的所有的线程。

这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法，必须要明确到底操作的是哪个锁上的线程。

为什么操作线程的方法wait notify notifyAll 定义在了Object类中？

因为这些方法是监视器的方法，监视器其实就是锁，锁可以是任意的对象，任意的对象调用的方式一定定义在Object类中。

Demo：

class Resource
{
	String name;	// 姓名
	String sex;		// 性别
	boolean flag = false;	// 用于判断是否输入数据，是否输出数据
}

class Input implements Runnable
{

	// 接收操作的资源的地址
	private Resource r;
	Input(Resource r)
	{
		this.r = r;
	}

	public void run()
	{
		boolean flag = true;
		while(true)
		{
			// 加上同步，是因为可能赋值赋到给name的时候
			//线程就切换到了输出了，那么sex还没有赋值，这就会出现name和sex不对应的错误
			synchronized(r)
			{
				// 如果是true，那么说明已经输入了数据了，当前线程等待状态，让输出线程进行输出
				// 等输出之后，在输出代码那里对这里的等待进行唤醒，重新输入数据
				if(r.flag)
				{
					try
					{
						r.wait();
					}
					catch (InterruptedException e)
					{
						e.printStackTrace();
					}
				}
				if(flag)
				{
					r.name = "hazy";
					r.sex = "boy";
					flag = false;
				}
				else
				{
					r.name = "小赖";
					r.sex = "女女女女女女";
					flag = true;
				}	
				r.flag = true;	// 当输入了数据之后，重新置为等待状态
				r.notify(); // 唤醒输出线程，进行输出
			}
		}
	}
}

class Output implements Runnable
{
	// 接收操作的资源的地址
	private Resource r;
	Output(Resource r)
	{
		this.r = r;
	}

	public void run()
	{
		while(true)
		{
			// 因为资源类是唯一的，并且输入和输出操作的是同一个资源对象，那么可以作为同步锁
			synchronized(r)
			{
				// 如果输出了，那就等待输入线程输入
				if(!r.flag)
				{
					try
					{
						r.wait();
					}
					catch (InterruptedException e)
					{
						e.printStackTrace();
					}
				}
				System.out.println(r.name + " ...... " + r.sex);
				r.flag = false;	// 输出了，置为等待
				r.notify();		// 唤醒输入线程
			}
		}
	}

}

class ResourceDemo 
{
	public static void main(String[] args) 
	{
		// 创建资源
		Resource r = new Resource();
		// 创建任务
		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 Resource
{
	private String name;	// 姓名
	private	String sex;		// 性别
	private boolean flag = false;	// 用于判断是否输入数据，是否输出数据

	// 输入
	public synchronized void set(String name, String sex)
	{
		if(flag)
		{
			try
			{
				this.wait();
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
		this.name = name;
		this.sex = sex;
		flag = true;
		notify();
	}

	// 输出
	public synchronized void out()
	{
		if(!flag)
		{
			try
			{
				this.wait();
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
		System.out.println(name + "...+..." + sex);
		flag = false;
		notify();
	}
}

class Input implements Runnable
{

	// 接收操作的资源的地址
	private Resource r;
	Input(Resource r)
	{
		this.r = r;
	}

	public void run()
	{
		boolean flag = true;
		while(true)
		{			
			if(flag)
			{
				r.set("hazy", "boy");
				flag = false;
			}
			else
			{
				r.set("小赖", "女女女女女女");
				flag = true;
			}
		}
	}
}

class Output implements Runnable
{
	// 接收操作的资源的地址
	private Resource r;
	Output(Resource r)
	{
		this.r = r;
	}

	public void run()
	{
		while(true)
		{
			r.out();
		}
	}

}

class ResourceDemo2
{
	public static void main(String[] args) 
	{
		// 创建资源
		Resource r = new Resource();
		// 创建任务
		Input in = new Input(r);
		Output out = new Output(r);
		// 创建线程，执行路径。
		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);
		// 开启线程
		t1.start();
		t2.start();
	}
}

多生产者，多消费者问题

使用多线程实现多个生产者，多个消费者交替执行生成和消费功能。

假如有两个生产者，两个消费者，如果生产者还未有生产产品，那么消费者不能进行消费，所以在资源里有一个flag标记是否生产了（或者说是否有产品），

有一个生成者生成了产品，此时只能给执行权只能给两个消费者进行抢夺，所以用了while来判断flag。

但是仅有while在唤醒后做判断是不够的，因为notify唤醒的是线程池里任意一个线程，有可能消费者都在等待状态，生产者生产了之后唤醒的还是生产者，有可能出现死锁，所以使用notifyAll代替notify可以解决问题。

/**
 * 生产者，消费者
 * 
 * 多生产者，多消费者的问题。
 * if判断标记，只有一次，会导致不该运行的线程运行了，出现数据错误的情况。
 * while判断标记，解决了线程获取执行权后，是否运行。
 *
 * notify：只能唤醒一个线程，如果本方唤醒了本方，没有意义。而且while判断标记+notify会导致死锁的出现。
 * notifyAll：解决了该问题，本方线程一定会唤醒对方线程。
 */

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

	// 输入
	public synchronized void set(String name)
	{
		// 当线程被唤醒之后，重新判断flag
		while(flag)
		{
			try
			{
				this.wait();
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
		this.name = name + count;
		count++;
		System.out.println(Thread.currentThread().getName() + "...生产者....生产" + this.name);
		flag = true;
		notifyAll(); // 之所以唤醒所有，是因为避免死锁，有可能四个线程都处于等待状态
	}
	
	// 输出
	public synchronized void out()
	{
		while(!flag)
		{
			try
			{
				this.wait();
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName() + "...........消费者...消费" + this.name);
		flag = false;
		notifyAll();
	}
}

class Producer implements Runnable
{
	private Resource r;
	
	Producer(Resource r)
	{
		this.r = r;
	}

	public void run()
	{
		while(true)
			r.set("烤鸭");
	}
}

class Consumer implements Runnable
{
	private Resource r;
	
	Consumer(Resource r)
	{
		this.r = r;
	}
	
	public void run()
	{
		while(true)
			r.out();
	}
	
}

class  ProducerConsumerDemo
{
	public static void main(String[] args) 
	{
		// 创建资源
		Resource r = new Resource();
		// 创建任务
		Producer p = new Producer(r);
		Consumer c = new Consumer(r);
		// 创建线程
		Thread t0 = new Thread(p);
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(c);
		Thread t3 = new Thread(c);

		t0.start();
		t1.start();
		t2.start();
		t3.start();
	}
}

多生产者多消费者-jdk1.5解决方法

jdk1.5以后将同步和锁封装成对象，并将操作锁的隐式方式定义到了该对象中，将隐式动作变成显式动作。

Lock接口：出现替代了同步代码块或者同步函数，将同步的隐式锁操作变成显式锁操作。同时更为灵活，可以一个锁上加上多组监视器。

Condition接口：出现替代了Object中的wait、notify、notifyAll方法，将这些监视器的方法单独进行了封装，变成Condition监视器对象，可以和任意锁组合。

await();代替wait();

signal();代替notify();

signalAll();代替notifyAll();

这里使用Lock对象代替了synchronized同步代码块，使用Condition对象代替了监视器，以往都是使用一个锁来进行监视多个线程，现在可以通过lock锁来实例化多个监视器，对不同线程或者说不同觉得进行监视。

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

class Resource
{
	private String name;
	private int count = 1;

	// 实例化一个互斥锁
	private Lock lock = new ReentrantLock(); 
	// 通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者
	private Condition producer_con = lock.newCondition(); // 生产者监视器
	private Condition consumer_con = lock.newCondition(); // 消费者监视器
	
	// 标记是否生产，是否消费
	private boolean flag = false;

	public void set(String name)
	{
		lock.lock();	// 获取锁
		try
		{
			while(flag)
			{
				try
				{
					producer_con.await();
				}
				catch (InterruptedException e)
				{
					e.printStackTrace();
				}
			}
			this.name = name + count;
			count++;
						System.out.println(Thread.currentThread().getName() + ".............生产者5.0...." + this.name);
			flag = true;
			// 产品生产了之后，唤醒消费者来进行消费，所以使用消费者监视器
			consumer_con.signal();	// 任意叫一个即可
		}
		finally
		{
			lock.unlock();	// 释放锁
		}
	}

	public void out()
	{
		lock.lock();	// 获取锁

		try
		{
			// 如果已经消费了，那么当然就是等待生产啦
			while(!flag)
			{
				try
				{
					consumer_con.await();
				}
				catch (InterruptedException e)
				{
					e.printStackTrace();
				}
			}
			// 被唤醒了，当然就是开始消费啦，消费了之后，再当然叫生产者继续生产啦
			System.out.println(Thread.currentThread().getName() + "...消费者5.0..." + this.name);
			flag = false; // 消费了就等待生成
			producer_con.signal(); // 唤醒一个生产者进行生产
		}
		finally
		{
			lock.unlock();
		}
	}
}

// 生产者
class Producer implements Runnable
{
	private Resource r;
	Producer(Resource r)
	{
		this.r = r;
	}
	
	public void run()
	{
		while(true)
		{
			r.set("烤鸭");
		}
	}
}

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

	public void run()
	{
		while(true)
		{
			r.out();
		}
	}
}


class ProducerConsumerDemo2
{
	public static void main(String[] args) 
	{
		// 创建资源
		Resource r = new Resource();
		// 创建生产者和消费者
		Producer p = new Producer(r);
		Consumer c = new Consumer(r);
		// 创建线程
		Thread t0 = new Thread(p);
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(c);
		Thread t3 = new Thread(c);
		// 开启线程
		t0.start();
		t1.start();
		t2.start();
		t3.start();

	}
}

sleep和wait的区别

1、wait可以指定时间，也可以不指定。
      sleep必须指定时间。
2、在同步中时，对cpu的执行权和锁的处理不同。
      wait：释放执行权，释放锁。
      sleep：释放执行权，不释放锁。

停止线程的方式
1、stop方法。
2、run方法结束。
怎么控制线程的任务结束呢？
任务中都会有循环结构，只要控制住循环体就可以结束任务。
控制循环通常就用定义标记来完成。
但是如果线程处于了冻结状态，无法读取标记，又如何结束呢？
可以使用interrupt()方法将线程从冻结状态强制恢复到运行状态中，让线程具备cpu的执行资格。
但是强制动作会发生InterrupedException异常，需要进行处理。可以在interrupt()后，让线程读取标记。

class StopThread implements Runnable
{
	// 标记，决定线程的结束的，也就是决定run方法执行的代码是否结束
	private boolean flag = true; 

	public synchronized void run()
	{
		while(flag)
		{
			try
			{
				wait();
			}
			catch (InterruptedException e)
			{
				System.out.println(Thread.currentThread().getName() + ".........." + e);
				setFlag(false); // interrupt后发生异常，然后更改标记，让线程读取
			}

			System.out.println(Thread.currentThread().getName() + "......run");
		}
	}

	public void setFlag(boolean f)
	{
		this.flag = f;
	}
}

class StopThreadDemo
{
	public static void main(String[] args){
		
		StopThread st = new StopThread();

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);

		t1.start();
		t2.start();

		int num = 1;
		for(;;)
		{
			if(num==50)
			{
				t1.interrupt();
				t2.interrupt();
				break;
			}
			System.out.println("thread..main..." + num++);
		}

	}
}

迷途小码农~

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——Java语言--多线程

———–android培训、java培训、java学习型技术博客、期待与您交流！————概述首先先了解一下进程，进程：正在进行中的程序。（直译）线程：就是进程中一个负责程序执行的控制单元（执行路径），一个进程中可以有多个执行路径，称之为——多线程。一个进程中至少有一个线程。开启多个线程是为了同时运行多部分代码，每一个线程都有自己运行的内容，这
复制链接

扫一扫

专栏目录