程序、进程和线程
程序:指为了完成特定任务用某种语言编写的一组指令的集合。简单说,就是一段静态的代码。
进程:指程序的一次执行过程,是正在运行的一段程序,是一个动态的过程。
线程:一个程序内部的一条执行路径。进程可以细化为线程。
线程的创建
Thread类
- 每个线程都是通过某个特定Thread类的对象的run()方法来完成操作。
- 通过该Thread对象的start()方法来启动这个线程,而非直接调用run()。
继承Thread类
- 定义子类继承Thread类;
- 子类中重写Thread类中的run方法;
- 创建Thread子类对象,即创建了线程对象;
- 调用线程对象start方法:启动线程,调用run方法。
启动多线程必须调用start 方法,一个线程对象只能调用一次start()方法。只是通过手动调用run方法,并没有启动多线程模式。
//使用两个线程分别输出10以内的数字
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ": "+ i );
}
}
}
public class ThreadsTest {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
thread1.setName("Thread1");
thread1.start();
MyThread thread2 = new MyThread();
thread2.setName("Thread2");
thread2.start();
}
}
实现Runnable接口
- 定义子类,实现Runnable接口;
- 子类中重写Runnable接口中的run 方法;
- 通过Thread类含参构造器创建线程对象;
- 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中;
- 调用Thread类的start方法:开启线程,调用Runnable子类接口的run方法。
避免了单继承的局限性。且多个线程可以共享一个接口实现类的对象,非常适合多个相同线程来处理同一份资源。
//用两个线程分别输出10以内的数
class MyThread1 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
public class RunnableTest {
public static void main(String[] args) {
MyThread1 thread1 = new MyThread1();
Thread t1 = new Thread(thread1);
t1.start();
MyThread1 thread2 = new MyThread1();
Thread t2 = new Thread(thread2);
t2.start();
}
}
实现Callable接口
- 创建一个实现Callable的实现类;
- 实现call方法,将此线程需要执行的操作声明在call()中;
- 创建Callable接口实现类的对象;
- 将此Callable接口实现类的对象作为参数传递到FutureTask 构造器中,创建FutureTask对象;
- 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start();
- 获取Callable中call方法的返回值。
//用两个线程分别输出10以内的数
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
class Ticket6 implements Callable{
@Override
public Object call() throws Exception {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
return null;
}
}
public class TicketTest7 {
public static void main(String[] args) {
Ticket6 c1 = new Ticket6();
FutureTask f1 = new FutureTask(c1);
Thread t1 = new Thread(f1);
t1.setName("窗口1");
t1.start();
Ticket6 c2 = new Ticket6();
FutureTask f2 = new FutureTask(c2);
Thread t2 = new Thread(f2);
t2.setName("窗口2");
t2.start();
}
}
相比于run()方法,可以有返回值,可以抛出异常,支持泛型的返回值。
线程池
- 提供指定线程数量的线程池;
- 执行指定的线程的操作。需要提供实现Runnable接口或者Callable接口实现类的对象;
- 关闭连接池。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
class Number implements Runnable{
@Override
public void run() {
for (int i = 0; i <10; i++) {
System.out.println(Thread.currentThread().getName() + ": "+ i);
}
}
}
class Number1 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
public class ThreadPoolTest {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
service1.setCorePoolSize(15);
service.execute(new Number());
service.execute(new Number1());
service.shutdown();
}
}
减少了创建新线程的时间,提高了响应速度;
重复利用线程池中的线程,不需要每次都创建,降低了资源消耗;
便于线程管理。
线程的生命周期
新建:当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态。
就绪:处于新建状态的线程被start()后,将进入线程队列等待CPU时间片,此时它已经具备了运行的条件,只是没分配到CPU资源。
运行:当就绪的线程被调度并获取CPU资源时,便进入运行状态,run()方法定义了线程的操作和功能。
阻塞:在某种特殊情况下,被认为挂起或执行输入输出操作时,让出CPU并临时中止自己的执行,进入阻塞状态。
死亡:线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。
线程生命周期转换图
线程的同步
线程安全问题:多个线程执行的不确定性引起的执行结果的不稳定,有可能造成数据破坏。
以买票窗口为例,以下代码为不安全示例:(使用继承Thread的方式来创建线程)
class Ticket extends Thread{
private static int ticket = 100;
@Override
public void run() {
while(true) {
if(ticket > 0){
System.out.println(Thread.currentThread().getName() + ": " + ticket);
ticket--;
}else{
break;
}
}
}
}
public class TicketTest1 {
public static void main(String[] args) {
Ticket t1 = new Ticket();
Ticket t2 = new Ticket();
Ticket t3 = new Ticket();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
解决方案:
- 同步代码块
synchronized(对象){
//需要被同步的代码块;
}
使用同步代码块解决继承Thread类的方式的线程安全问题:使用当前类充当同步监视器。
class Ticket1 extends Thread {
private static int ticket = 100;
@Override
public void run() {
while(true) {
synchronized (Ticket1.class){
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": " + ticket);
ticket--;
}else{
break;
}
}
}
}
}
public class TicketTest2 {
public static void main(String[] args) {
Ticket1 t1 = new Ticket1();
Ticket1 t2 = new Ticket1();
Ticket1 t3 = new Ticket1();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
使用同步代码块解决实现Runnable接口创建多线程方式的线程安全问题:使用this充当同步监视器。
class Ticket2 implements Runnable{
private static int ticket = 100;
@Override
public void run() {
while(true){
synchronized(this){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() + ": " + ticket);
ticket--;
}else {
break;
}
}
}
}
}
public class TicketTest3 {
public static void main(String[] args) {
Ticket2 r = new Ticket2();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
Thread t3 = new Thread(r);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
- 同步方法
public synchronized void show(String name){
...
}
使用同步方法解决继承Thread类的方式中的安全问题:加static关键字,使得同步监视器统一。
class Ticket3 extends Thread{
private static int ticket = 100;
@Override
public void run() {
while(true){
show();
}
}
public static synchronized void show(){
if(ticket > 0){
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": " + ticket);
ticket--;
}
}
}
public class TicketTest4 {
public static void main(String[] args) {
Ticket3 t1 = new Ticket3();
Ticket3 t2 = new Ticket3();
Ticket3 t3 = new Ticket3();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
使用同步方法解决实现Runnable接口创建线程的安全问题:使用synchronized方法。
class Ticket4 implements Runnable{
private int ticket = 100;
@Override
public void run() {
while(true){
show();
}
}
public synchronized void show(){
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": " + ticket);
ticket--;
}
}
}
public class TicketTest5 {
public static void main(String[] args) {
Ticket4 r = new Ticket4();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
Thread t3 = new Thread(r);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
- Lock锁
与前两种方法的区别:前两种方法在执行完相应的同步代码以后,自动释放同步监视器;但是Lock锁需要手动启动同步也需要手动结束同步。
import java.util.concurrent.locks.ReentrantLock;
class Ticket5 implements Runnable{
private int ticket = 100;
ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
lock.lock();
if(ticket > 0){
System.out.println(Thread.currentThread().getName() + ": " + ticket);
ticket--;
}else {
break;
}
lock.unlock();
}
}
}
public class TicketTest6 {
public static void main(String[] args) {
Ticket5 r = new Ticket5();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
Thread t3 = new Thread(r);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
优先使用顺序:Lock锁——>同步代码块(已经进入方法体,分配了相应资源)——>同步方法(在方法体之外)
线程的通信
wait():令当前线程挂起并放弃CPU、同步资源并等待,使别的线程可访问并修改共享资源,而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒,唤醒后等待重新获得对监视器的所有权后才能继续执行。
sleep()和wait()的异同:
相同点:一旦执行都可以使得线程进入阻塞状态。
不同点:方法声明位置不同,Thread类中声明sleep(),Object类中声明wait();调用要求不同,sleep()可以在任何需要的场景下调用,wait()必须在同步代码块或同步方法中调用;sleep()不会释放同步监视器,wait()会释放同步监视器。
notify():唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll():唤醒正在排队等待资源的所有线程结束等待.
这三个方法只有在synchronized 方法或者synchronized 代码块中才能使用。
调用者必须是同步代码块或同步方法中的同步监视器,否则会出现IllegalMonitorStateException异常。
这三个方法定义在java.lang.Object类中。
生产者—消费者问题
class Clerk{
private int productCount = 0;
public synchronized void produceProduct(){
if(productCount < 5){
productCount++;
System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品");
notify();
}else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void consumeProduct(){
if(productCount > 0){
System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
productCount--;
notify();
}else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Producer implements Runnable{
private Clerk clerk;
public Producer(Clerk clerk){
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":开始生产产品");
while(true){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProduct();
}
}
}
class Consumer implements Runnable {
private Clerk clerk;
public Consumer(Clerk clerk){
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":开始消费产品");
while (true){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumeProduct();
}
}
}
public class ProducerAndConsumer {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer p1 = new Producer(clerk);
Consumer c1 = new Consumer(clerk);
Thread t1 = new Thread(p1);
Thread t2 = new Thread(c1);
Thread t3 = new Thread(c1);
t1.setName("生产者");
t2.setName("消费者1");
t3.setName("消费者2");
t1.start();
t2.start();
t3.start();
}
}