要学习多线程,需要了解什么是"线程"?要了解线程,首先先了解一下什么是"进程"?
线程在游戏中的应用体现是最为明显的,当你使用一个账号登录时,在进行游戏的过程中,我们游戏角色的生死存亡就是挂在一个线程上。如果是攻城式的游戏,即自带小兵攻击,我们经常玩游戏的应该有感受,当你被消灭时,你的小兵也会跟着死掉,这其实就是在后面会提到的daemon守护线程的操作,这个会在后面展现出来!来来,入门伸头看看咯!
什么是进程?一般来说一个应用程序开始运行,它就是一个主"进程"。它由操作系统管理;每一个进程都有它自己的内存空间和系统资源。
什么是线程?线程,是由某个进程单独启动的一个独立运行代码块。一个线程,一旦启动之后,同主进程一样,一起竞争系统资源。一个进程,可以开出很多的线程。一个线程就是一个单独的执行路径。多个线程,就是多个执行路径,所有的这些执行路径同时竞争系统资源;
单线程和多线程:
1).单线程:一个应用程序只有一条执行路径。(之前我们开发的所有程序)
2).多线程:一个应用程序开出多个线程,也就是具有多个执行路径。
Java程序运行的原理:
1).由虚拟机加载启动的main()方法所在类。
2).同时,虚拟机在后台也会运行一些其他的程序:例如:垃圾回收器。
3).java虚拟机也是一个多线程的程序;
什么是并行和并发?
前者是逻辑上同时发生,指在"某一个时间内"同时运行多个程序。
后者是物理上同时发生,指在"某一个时间点"同时运行多个程序。
那么,我们能不能实现真正意义上的并发呢,是可以的,多个CPU就可以实现,不过你得知道如何调度和控制它们。
/*
- 线程的实现方式一:
- 步骤:
- 1.定义一个类,继承自java.lang.Thread
- 2.重写里面的run()方法;
- 3.在测试类中,实例化自定义类的对象,并调用它的start()方法,启动一个线程;
- 线程的实现方式二:
- 步骤:
- 1.定义一个类,实现Runnable接口;
- 2.重写里面的run()方法;
- 3.在测试类中:
- 1).实例化自定义类的对象;
- 2).Thread t = new Thread(自定义类对象引用);
-
t.start();
-
简化的写法:
-
new Thread(自定义类对象引用).start( );
package com.myTest.demo02_线程的实现方式一;
public class Demo {
public static void main(String[] args) {
//3.在测试类中,实例化自定义类的对象,并调用它的start()方法,启动一个线程;
MyThread t = new MyThread();
t.start();//启动线程,会执行run()方法
// t.run();//普通的方法调用,并不能作为一个线程启动。
// t.start();//对于同一个线程对象,不能多次的start();异常:IllegalThreadStateException
for(int j = 0;j < 20 ;j++){
System.out.println("j = " + j);
}
System.out.println("当前main()方法 的线程名称:" +
Thread.currentThread().getName());
System.out.println("main方法执行完毕!");
}
}
线程的实现方式一;
//1.自定义类,继承自Thread。代表我们的类就是一个Thread
public class MyThread extends Thread{
//2.重写Thread中的run()方法;在线程启动后,需要做的事情,写在run()方法中;
@Override
public void run() {
for(int i = 0;i < 20;i++){
System.out.println("i = " + i);
}
}
}
线程的调度_sleep 休眠;
线程的休眠:Thread --> public static void sleep(long millis)
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo {
public static void main(String[] args) {
/*for(int i = 1 ;i <= 10;i++){
//每秒打印一次
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateStr = sdf.format(date);
System.out.println("当前时间: " + dateStr);
//休息1秒
try {
//当前线程休眠
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}*/
//启动线程
MyThread t = new MyThread();
t.start();
}
}
import java.text.SimpleDateFormat;
import java.util.Date;
public class MyThread extends Thread {
@Override
public void run() {
for(int i = 1 ;i <= 10;i++){
//每秒打印一次
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateStr = sdf.format(date);
System.out.println("当前时间: " + dateStr);
//休息1秒
try {
//当前线程休眠
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
默认情况下,当前进程开出的所有线程都是"非守护线程":当主进程结束,会等待所有线程结束,应用程序才会结束;
让开出的线程作为"守护线程":Thread -->public final void setDaemon(boolean on):如果为true,为守护线程
守护线程:当主进程结束时,所有的"守护线程"也会结束。(但不会立即结束,通常会有个小缓冲)
后台线程_守护线程_setDaemon;
public class Demo {
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t1.setName("兵1");
t2.setName("兵2");
t1.setDaemon(true);
t2.setDaemon(true);
t1.start();
t2.start();
//主进程是将军
for(int i = 1 ;i <= 10;i++){
System.out.println("将军杀敌:" + i);
}
System.out.println("将军杀敌结束,收工!!");
}
}
public class MyThread extends Thread{
@Override
public void run() {
System.out.println("我是:" + this.getName() + " ,我要杀敌100.");
for(int i = 0;i < 100;i++){
System.out.println(this.getName() + " 杀敌:" + (i + 1));
}
System.out.println(this.getName() + " 杀完了!收工!!");
}
}
停止线程_interrupt;
- 停止线程:
- public final void stop():
public void interrupt():
public class Demo {
public static void main(String[] args) {
//启动MyThread,MyThread中的run会执行20秒,我们可以在主进程中,让
//MyThread执行3秒后,如果没有停止,那么就强行停止它
MyThread t = new MyThread();
t.start();
/*try {
Thread.sleep(1000 * 3);//等待3秒,MyThread会执行3秒
} catch (InterruptedException e) {
e.printStackTrace();
}*/
//强行去停止MyThread
// t.stop();//停止线程,但此方法已过时;
t.interrupt();//stop的替换方法;去使MyThread的run()抛出一个异常,在异常中,我们去结束线程执行;
}
}
public class MyThread extends Thread{
@Override
public void run() {
for(int i = 0;i < 20 ;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("线程抛出异常,出现意外情况了,我结束执行!");
break;
}
System.out.println("i = " + i);
}
}
}
- 线程的实现方式二:
- 步骤:
- 1.定义一个类,实现Runnable接口;
- 2.重写里面的run()方法;
- 3.在测试类中:
- 1).实例化自定义类的对象;
- 2).Thread t = new Thread(自定义类对象引用);
-
t.start();
-
简化的写法:
-
new Thread(自定义类对象引用).start();
public class Demo {
public static void main(String[] args) {
//3.1.实例化
MyRunnable myRun = new MyRunnable();
//3.2
/*Thread t1 = new Thread(myRun,"邓超");
Thread t2 = new Thread(myRun,"孙俪");
//启动线程
t1.start();
t2.start();*/
//简化写法
new Thread(myRun,"邓超").start();
new Thread(myRun,"孙俪").start();
}
}
public class MyRunnable implements Runnable{
@Override
public void run() {
for(int i = 0;i < 20;i++){
System.out.println(Thread.currentThread().getName() + " i = " + i);
}
}
}
Runnable接口实现卖票程序;
public class Demo {
public static void main(String[] args) {
TicketPool pool = new TicketPool();
SellTicketRunnable tRun1 = new SellTicketRunnable(pool);
SellTicketRunnable tRun2 = new SellTicketRunnable(pool);
SellTicketRunnable tRun3 = new SellTicketRunnable(pool);
new Thread(tRun1,"窗口1").start();
new Thread(tRun2,"窗口2").start();
new Thread(tRun3,"窗口3").start();
}
}
import java.util.ArrayList;
public class SellTicketRunnable implements Runnable {
private TicketPool pool = null;
//ArrayList不保证线程安全
private ArrayList<Integer> ticArray = new ArrayList<Integer>();
public SellTicketRunnable(TicketPool pool) {
this.pool = pool;
}
@Override
public void run() {
// 一直抢票,一直抢到返回值为0
while (true) {
int t = this.pool.getTicket();
if (t <= 0) {
System.out.println("没票了,我结束了!");
break;
}
// System.out.println(this.getName() + " 抢到票:" + t);
ticArray.add(t);// 将票装到集合中
}
System.out.println(Thread.currentThread().getName() + " 一共抢到:" + this.ticArray.size()
+ " 张票!");
}
}
public class TicketPool {
private int tickets = 100;
public int getTicket(){
if(tickets > 0){
return this.tickets--;
}else{
return 0;
}
}
}
进行同步操作后
加入同步代码块_synchronized;
/*
- 同步代码块,解决多线程环境下的并发问题:
- 问题:
- 1.是否是多线程环境
2.是否有共享数据
3.是否有多条语句操作共享数据
解决:将可能会被多个线程访问的代码进行"同步"使用关键字:synchronized
语法:synchronized(theObject){
//可能会被多个线程访问的代码
}
theObject:是一个对象,对其加锁的对象。表示,当我访问这个对象的某个同步代码块时,
其它的线程不能访问这个对象的同步方法或同步代码块
synchronized:
好处:代码在多线程环境下变得安全,数据变得可靠;
弊端:由于内部做了很多线程控制方面的工作,所以效率低。
public class Demo {
public static void main(String[] args) {
TicketPool pool = new TicketPool();
SellTicketThread t1 = new SellTicketThread(pool);
SellTicketThread t2 = new SellTicketThread(pool);
SellTicketThread t3 = new SellTicketThread(pool);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
import java.util.ArrayList;
public class SellTicketThread extends Thread {
private TicketPool tPool = null;
private ArrayList<Integer> ticArray = new ArrayList<Integer>();
public SellTicketThread(TicketPool pool){
this.tPool = pool;
}
@Override
public void run() {
//一直抢票,一直抢到返回值为0
while(true){
int t = this.tPool.getTicket();
if(t <= 0){
System.out.println("没票了,我结束了!");
break;
}
// System.out.println(this.getName() + " 抢到票:" + t);
ticArray.add(t);//将票装到集合中
}
System.out.println(this.getName() + " 一共抢到:" + this.ticArray.size() + " 张票!");
}
}
public class TicketPool {
private int tickets = 100;
public int getTicket(){//窗口1,窗口2
//比如这里有些复杂的操作,需要耗费5毫秒
synchronized(this){//下面这段代码具有多线程的安全性:窗口1 先进入
try {//这段代码块将会被锁定,不允许其它线程访问。如果有线程访问,将会列队等待,直到窗口1执行完毕;
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(tickets > 0){
return this.tickets--;
}else{
return 0;
}
}
//窗口1 执行完毕,解锁,其它线程才可以进入
}
}