1.jvm与多线程
jvm里分为方法区、虚拟机栈、本地方法栈、堆、程序计数器
每个进程在方法区与堆里有一份
每个线程在虚拟机栈与程序计数器里有一份
2.java程序中自带的线程
一个java.exe程序中，至少存在三个线程：主线程、垃圾回收线程、异常处理线程
3.创建线程方式一：继承Thread类
/**
* @author ym
* @create 2022-01-24 17:38
* @description 测试创建线程的方法，即继承thread类 得到100以内的所有偶数
*/
public class ThreadTest extends Thread {
@Override
public void run() {
for (int i = 0; i < 1001; i++) {
if (i % 2 == 0) {
System.out.println(i);
}
}
}
}
/**
* @author ym
* @create 2022-01-24 17:40
* @description
*/
public class ThreadTest1 {
public static void main(String[] args) {
ThreadTest threadTest = new ThreadTest();
threadTest.start();
for (int i = 0; i < 1001; i++) {
if (i % 2 == 0) {
System.out.println("main");
}
}
}
}
注意：
1.不能用直接调用run方法的方式开启线程，这样的话只是相当于普通的函数调用，并没有打开新的线程
2.不能再调用一个start()过了的线程对象的start()方法
4.线程中常用方法
/**
* @author ym
* @create 2022-01-24 17:40
* @description
*/
public class ThreadTest1 {
/**
* 线程中常用方法：
* 1.start():启动当前线程，调用当前线程的run()方法
* 2.run():重写Thread类中的此方法，将创建的线程要执行的内容声明在此处
* 3.currentThread():静态方法，返回执行当前代码的线程
* 4.getName():获取当前线程的名字
* 5.setName():设置当前线程的名字
* 6.yield():释放当前cpu的执行权
* 7.join():在a线程中调用b线程的join()方法，则a线程会一直阻塞到b线程完全执行结束
* 8.stop():已过时，当执行此方法时，强制结束当前线程
* 9.sleep(long milltime):休眠，休眠期间当前线程是阻塞状态
* 10.isAlive():判断当前线程是否存活
*
* @param args
*/
public static void main(String[] args) throws InterruptedException {
ThreadTest threadTest = new ThreadTest();
// 5.setName():设置当前线程的名字
Thread.currentThread().setName("主线程ym");
//1.start():启动当前线程，调用当前线程的run()方法
threadTest.start();
for (int i = 0; i < 1001; i++) {
if (i % 2 == 0) {
// 3.currentThread():静态方法，返回执行当前代码的线程
//4.getName():获取当前线程的名字
System.out.println(Thread.currentThread().getName() + "main\t" + i);
}
if (i == 800) {
// 7.join():在a线程中调用b线程的join()方法，则a线程会一直阻塞到b线程完全执行结束
threadTest.join();
}
if (i == 900) {
// 8.stop():已过时，当执行此方法时，强制结束当前线程
Thread.currentThread().stop();
}
}
}
}
/**
* @author ym
* @create 2022-01-24 17:38
* @description 测试创建线程的方法，即继承thread类 得到100以内的所有偶数
*/
public class ThreadTest extends Thread {
//2.run():重写Thread类中的此方法，将创建的线程要执行的内容声明在此处
@Override
public void run() {
// 5.setName():设置当前线程的名字
setName("测试线程ym");
for (int i = 0; i < 1001; i++) {
if (i % 2 == 0) {
//3.currentThread():静态方法，返回执行当前代码的线程
//4.getName():获取当前线程的名字
System.out.println(currentThread().getName() + i);
}
if (i == 700) {
try {
// 9.sleep(long milltime):休眠，休眠期间当前线程是阻塞状态
sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (i == 850) {
// 10.isAlive():判断当前线程是否存活
System.out.println(isAlive());
}
if (i % 10 == 0) {
// 6.yield():释放当前cpu的执行权
yield();
}
}
}
}
5.创建线程的第二个方法：实现runnable接口
/**
* @author ym
* @create 2022-01-24 20:36
* @description 第二种创建线程的方式，实现runnable接口
*/
public class ThreadTest2 {
public static void main(String[] args) {
MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();
Thread thread1 = new Thread(myThread);
thread1.start();
}
}
class MyThread implements Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see Thread#run()
*/
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(i + "\t" + Thread.currentThread().getName());
}
}
}
}
6.常见多线程初识问题：窗口卖票问题
需求：3个窗口共卖出100张票
实现方案1：用继承thread的方式，不过此时需注意，票数需要static
package com.exer;
/**
* @author ym
* @create 2022-01-24 20:12
* @description 三个窗口卖票问题
*/
public class TicketDemo {
public static int tickets = 100;
public static void main(String[] args) {
TicketSell ticketSell1 = new TicketSell();
TicketSell ticketSell2 = new TicketSell();
TicketSell ticketSell3 = new TicketSell();
ticketSell1.start();
ticketSell2.start();
ticketSell3.start();
}
}
class TicketSell extends Thread{
@Override
public void run() {
while (true){
if (TicketDemo.tickets>0){
TicketDemo.tickets--;
System.out.println(TicketDemo.tickets+"\t"+getName());
}else {
break;
}
}
}
}
**实现方案2：用实现runnable接口的方式，此时便不需将票数static了，因为每个线程都共用一个实现了runnable的线程操作对象 **
package com.exer;
/**
* @author ym
* @create 2022-01-24 20:45
* @description
*/
public class TicketDemo1 {
public static void main(String[] args) {
MyThread myThread = new MyThread();
Thread thread1 = new Thread(myThread);
Thread thread2 = new Thread(myThread);
Thread thread3 = new Thread(myThread);
thread1.start();
thread2.start();
thread3.start();
}
}
class MyThread implements Runnable {
public int tickets = 100;
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see Thread#run()
*/
@Override
public void run() {
while (true) {
if (tickets > 0) {
tickets--;
System.out.println(Thread.currentThread().getName() + "\t" + tickets);
} else {
break;
}
}
}
}
7.总结:在开发中，多线程创建尽量使用实现runnable()接口的方法，原因：
1.实现的方式没有类的单继承性的局限
2。实现的方式更适合来处理多个线程有共享数据的情况