2021-05-25

Java学习

day22

多线程

目录

1. 线程
2. Thread类
3. Runnable 接口
   

1.1、并发与并行

• 并发:指两个成多个事件在同一个时间段内发生。
• 并行:指两个成多个事件在同一时刻发生(同时发生)。

在操作系统中，安装了多个程序，并发指的是在段时间内宏观上有多 个程序同时运行，这在单CPU系统中，每时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

而在多个CPU系统中，则这些可以并发执行的程序便可以分配到多个处理器上(CPU) ，实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行，目前电脑市场上说的多核CPU,便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

• 注意:单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理线程也是样的， 从宏观角度上理解线程是井行运行的，但是从微观角度上分析却是串行运行的，即个线程个线程的去运行， 当系统只有一个CPU时，线程会以某种顺序执行多个钱程，我们把这种情况称之为线程调度。

1.2、线程与进程

• 进程: 是一个内存中运行的应用程序，每个进程都有个独立的内存空间，一个应用程序可以同时运行多个进程;进程也是程序的一次执行过程，是系统运行理序的其本单位;系统运行一个程序即是一个进程从创建、运行到消亡的过程。
• 线程: 线程是进程中的个执行单元，负责当前进程中程序的执行，一个进程中至少有一 个线程。一个进程中是可以有多个线程的， 这个应用程序也可以称之为多线程程序。
• 进而言之，一个程序运行后，至少有一个进程，一个进程中可以包含多个线程。我们可以在电脑底部任务栏，点击右键打开任务管理器，可以查看当前任务的进程。

1.3、线程的概念
在Java中，县城由三个部分组成，虚拟的CPU、代码和数据。
①虚拟的CPU: 专门用于执行线程的任务。在java.lang.Thread类封装和虚拟。
②代码: 线程中执行的指令，即程序中特定的方法。在Java中构造Thread类时，传递给Thread类对象。
③数据: 线程中要处理的数据及程序中的变量等。

1.4、创建线程类
Java使用java.lang.Thread类代表线程，所有的线程对像都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码， Java使用线程代程执行来代表这段程序流，Java中通过继承Thread类来创建并启动多线程的步骤如下:

1. 定义Thread类的子类
2. 重写该类的run( )方法，该run)方法的方法体就代表了线程需要完成的任务，因此把run(）方法称为线程执行体
3. 创建Thread子类的实例， 即创建了线程对象
4. 利用线程对象的start( )方法来启动流线程

• 例一:
  主线程 执行main（）方法的线程
  单线程程序：只有一个线程在执行，从头到尾
  运行结果如下:
  ①

package Demo01;

public class Person {
	private String name;

	public String getName() {
		return name;
	}

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

	public Person() {
		
	}
	
	public void run() {
		for(int i=0;i<20;i++)
		{
			System.out.println(name+"-->"+i);
		}
	}
}

②

package Demo01;
/*
 * 主线程  执行main（）方法的线程
 * 单线程程序：只有一个线程在执行，从头到尾
*/
public class Demo01MainThread {
	public static void main(String[] args) {
		Person p1 = new Person("小张");
		p1.run();
		
		//System.out.println(0/0);
		
		Person p2 = new Person("小曾");
		p2.run();
	}
}

运行结果:

• 例二:
  运行代码如下:
  ①

package Demo01;
//1、创建Thread子类
public class MyThread extends Thread {
	//2、重写run方法
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("子线程："+i);
		}	
	}
}

②

ackage Demo01;
/*
 * java.long.Thread
 
 * 实现步骤：
 * 1、创建一个Thread类的子类
 * 2、在Thread子类中重写run方法，设置线程任务（干什么）
 * 3、创建Thread子类的对象
 * 4、调用Thread类中start方法来启动线程，执行run方法
*/
public class Demo02Thread {
	public static void main(String[] args) {
		//3.创建Thread子类的对象
		MyThread mt = new MyThread();
		
		//4.调用start方法
		mt.start();
		
		for(int i=0;i<10;i++) {
			System.out.println("主线程："+i);
			//if(i==10)
				//System.out.println(0/0);
		}
	}
}

运行结果如下:

Thread 类

java.lang.Thread类，API中该类中定义了有关线程的一些方法，具体如下:
构造方法:

• public Thread() :分配一个新的线程对象。
• public Thread (String name): 分配一个指定名字的新的线程对象。
• public Thread (Runnable target): 分配一个带有指定自标新的线程对象
• publis Thread (Runnable target,string name): 分配一个带有指定目标新的线程对象并指定名字。
  常用方法:
• public string getName() :获取当前线程名称。
• publie vold start() :导致此线程开始执行: Java虚拟机调用此线程的run方法。
• publlc vold run() :此线程要执行的任务在此处定义代码。
• public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
• publlc static Thread currentThread() :返回对当前正在执行的线程对象的引用。

翻阅API后得如创建线程的方式总共有两种，- 种虽继承Thred类方式，一种是实现Runnable接口方式。

• 例三:
  运行代码如下:
  ①

package Demo02;
//1、创建Thread子类
public class MyThread extends Thread {
	//2、重写run方法
	@Override
	public void run() {
		//String name = new getName();
		//System.out.println("run:"+name);
		
		System.out.println("子"+Thread.currentThread().getName());
	}	
}

②

package Demo02;

import Demo01.MyThread;

public class Demo01Thread {
	public static void main(String[] args) {
		//3.创建Thread子类的对象
		MyThread mt = new MyThread();
		
		//4.调用start方法
		mt.start();//子进程0
		
		new MyThread().start();//子进程1
		new MyThread().start();//子进程2
		new MyThread().start();//子进程3
		
		System.out.println("main:"+Thread.currentThread().getName());
	}
}

运行结果如下:

• 例四:
  运行代码如下:
  ①

package Demo02;

public class MyThreadName extends Thread {
	public MyThreadName() {}
	public MyThreadName(String name) {
		super(name);//把线程名字传递给父类，让父类Thread给子线程起一个名字
	}
	//重写run方法
	@Override
	public void run() {
		//String name = new getName();
		//System.out.println("run:"+name);
		System.out.println("子"+Thread.currentThread().getName());
	
	}	
}

②

package Demo02;

public class Demo02ThreadSetName {
	public static void main(String[] args) {
		MyThreadName mt = new MyThreadName("小不点");
		
		mt.start();//开始执行
		
		new MyThreadName("招财猫").start();
	}
}

运行结果如下:

• 例五:Sleep
  运行代码:

package Demo03;

public class Demo01Sleep {
	public static void main(String[] args) {
		for(int i=0;i<10;i++) {
			System.out.println(i);
			
			try {
				Thread.sleep(1000);//以毫秒为单位
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
			
		}	
	}
}

运行结果:

3、Runnable 类

采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。

• 步骤如下:

1.定义Runnable接口的实现类，并重写该接口的run(）方法，该run(）方法的方法体同样是该线程的线程执行体。
2.创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
3.调用线程对象的start(）方法来启动线程。

• 例六:
  运行代码如下:
  ①

package Demo04;
//功能实现类
//1.创建一个runnable接口的实现类
public class RunnableImpl implements Runnable {
//2.在实现类中，重写runnable中的run方法，设置线程任务
	@Override
	public void run() {
		for(int i=0;i<20;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	}
}

②

package Demo04;

public class RunnableImpl2 implements Runnable {
	@Override
	public void run() {
		for(int i=0;i<20;i++) {
			System.out.println("Helloworld-->"+i);
		}	
	}
}

③

package Demo04;
/*
 * 实现runnable接口创建多线程的好处：
 * 1、避免了单继承的局限性
 * 2、增强了程序的扩展性，降低了程序的耦合性
*/
public class Demo01Runnable {
	public static void main(String[] args) {
		//3.创建一个runnable接口实现类对象
		RunnableImpl run = new RunnableImpl();
		
		//4.创建Thread类对象，构造方法中传递Runnable 接口实现类对象
		//Thread t = new Thread(run);
		Thread t = new Thread(new RunnableImpl2());
		//5.调用Thread类中的start方法，启动子线程
		t.start();
		
		for(int i=0;i<20;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
 	    }
	}
}

运行结果:

• 例七:
  运行代码如下:
  ①

package Demo05ThreadSafe;
public class RunnableImpl implements Runnable {
	private int ticket = 100;
	Object obj = new Object();
	@Override
	public void run() {
		while(true) {
			synchronized(obj) {
			if(ticket>0) {
				try {
					Thread.sleep(1);
				}catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"-->正在买第"+ticket+"张票");
				ticket--;
			  }
		   }
		}
	}
}

②

package Demo05ThreadSafe;

public class Demo01Ticket {
	public static void main(String[] args) {
		RunnableImpl run = new RunnableImpl();
		
		Thread t0 = new Thread(run);
		Thread t1 = new Thread(run);
		Thread t2 = new Thread(run);
		
		t0.start();
		t1.start();
		t2.start();
	}
}

运行结果:

tip :2020080605006