• 中文
    • English
  • 注册
  • 查看作者
  • Java 线程基础

    线程基础进程线程(数据结构)进程是程序的一次执行过程,或者是政治运行的一个程序。线程是由进程创建,是进程的一个实体,一个进程可以拥有多个线程。

    并发并行单线程:同一个时刻,只允许执行一个线程

    多线程:同一时刻,可以执行多个线程

    并发:同一时刻,多个任务交替执行。单核CPU实现的多任务就是并发

    并行:同一时刻,多个任务同事执行。多核CPU可以实现并行

    package opp1;

    import org.omg.SendingContext.RunTime;

    public class demo01 {public static void main(String[] args) {Runtime runtime = Runtime.getRuntime();int cpuNums = runtime.availableProcessors();System.out.println(cpuNums); //显示cpu核数

    }继承Thread创建线程创建线程的两种方法:

    继承Thread类,重写run方法实现runnable接口,重写run方法package opp1;

    /**

    • 继承Thread创建线程*/public class demo02 {public static void main(String[] args) {//创建Cat对象Cat cat = new Cat();cat.start(); //启动线程}}

    //1. 当一个类继承了Thread类,该类就可以当作线程使用//2. 我们会重写run方法,写上自己的业务代码//3. run Thread 类 实现了 Runnable接口的run方法

    class Cat extends Thread{int times = 0;@Overridepublic void run() { //重写run方法,写上自己的业务逻辑while (true) {//每隔一秒。控制台输出“喵喵”,共10次.执行完毕结束System.out.println(“喵喵” + (++times));try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}if (times ==10){break; //当times=10时候,进程退出}}}}多线程机制当mian线程启动一个子线程 Thread-0 ,主线程不会阻塞,会继续执行

    package opp1;

    /**

    • 继承Thread创建线程*/public class demo02 {public static void main(String[] args) throws InterruptedException {//创建Cat对象Cat cat = new Cat();cat.start();//当mian线程启动一个子线程 Thread-0 ,主线程不会阻塞,会继续执行//这时,我们的子线程会交替执行

    • }}

    //1. 当一个类继承了Thread类,该类就可以当作线程使用//2. 我们会重写run方法,写上自己的业务代码//3. run Thread 类 实现了 Runnable接口的run方法

    class Cat extends Thread{int times = 0;@Overridepublic void run() { //重写run方法,写上自己的业务逻辑while (true) {//每隔一秒。控制台输出“喵喵”,共80次.执行完毕结束System.out.println(“喵喵” + (++times) + ” 子线程”+Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}if (times ==80){break; //当times=80时候,进程退出}}}}Java 线程基础插图

    start为什么调用stat方法?

    cat.start(); //最终会执行cat的run()方法

    cat.run(); //run方法只是一个普通方法,没有真正启动一个线程,就会把run方法执行完毕,才向下执行

    Java 线程基础插图1

    Runnable创建线程package opp1;

    /**

    • Runnable接口 实现创建线程

    • 这里底层使用了设计模式:代理模式*/

    public class demo03 {public static void main(String[] args) {Dog dog = new Dog();// dog.start(); 这里不能用start

    }

    class Dog implements Runnable{ //通过Runnable接口,开发线程int count = 0;@Overridepublic void run() {while(true){System.out.println(“小狗汪汪叫 ” +(++count) + Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}if (count == 10){break;}}}}子线程package opp1;

    /**

    • main方法实现两个子线程*/public class demo04 {public static void main(String[] args) {T1 t1 = new T1();T2 t2 = new T2();Thread thread = new Thread(t1); //新建一个进程Thread thread1 = new Thread(t2);// Thread thread2 = new Thread(t2);thread.start(); //启动第一个子线程thread1.start(); //启动第二个子线程}}

    class T1 implements Runnable{

    }

    class T2 implements Runnable{

    }多线程售票经典售票问题

    package opp1;

    /**

    • 使用多线程,模拟三个窗口同时售票,每个窗口都会卖出100张票*/

    public class demo05 {public static void main(String[] args) {

    // SellTicket01 sellTicket01 = new SellTicket01();// SellTicket01 sellTicket02 = new SellTicket01();// SellTicket01 sellTicket03 = new SellTicket01();// ////// //会出现超卖的现象,sleep时间越短,就会出现超卖现象// sellTicket01.start();// sellTicket02.start();// sellTicket03.start();

    }

    class SellTicket01 extends Thread{

    }

    class SellTicket02 implements Runnable{private static int num = 100; //让多个线程共享num@Overridepublic void run() {while (true){if (num <=0){System.out.println(Thread.currentThread().getName() + "售票结束");break;}

    }通知线程退出当线程完成任务后,会自动退出还可以通过 使用变量 来控制 run方法退出的方式停止线程,即 通知方式package opp1;

    public class demo06 {public static void main(String[] args) throws InterruptedException {T t1 = new T();t1.start();

    }

    class T extends Thread{int count = 0;private boolean loop = true;@Overridepublic void run() {while (loop){

    }线程中断线程常用的方法第一组:

    setName //设置线程名称getName //返回该线程名称start //使该线程开始执行;Java虚拟机底层调用该线程的start0方法run //调用线程对象run方法setPriority //修改线程优先级getPriority //获得线程优先级sleep //在指定的毫秒数没让当前正在执行的线程休眠interrupt //中断进程注意事项和细节

    start 底层会创建新的进程,调用run,run就是一个简单方法调用,不会启动新线程线程优先级的范围interrupt,中断进程,但是并没有真正结束进程。多以一般用于种端正在休眠的进程sleep:线程的静态方法,使当前线程休眠package opp1;

    public class demo07 {public static void main(String[] args) throws InterruptedException {T3 t3 = new T3();t3.setName(“摩拉克斯”);t3.setPriority(Thread.MIN_PRIORITY);t3.start();

    }

    class T3 extends Thread{ //自定义的线程类@Overridepublic void run() {for (int i = 0; i < 100; i++) {//Thread.currentThread().getName() 获取当前线程的名称System.out.println(Thread.currentThread().getName() + "吃包子" + i);}

    }线程插队常用方法第二组

    yield : 线程的礼让。让出CPU,让其他线程执行,但是礼让时间不确定,所以也不一定礼让成功join :线程插队。插队的线程一旦插队成功,则肯定先执行完插入线程的所有任务。package opp1;

    public class demo08 {public static void main(String[] args) throws InterruptedException {T5 t5 = new T5();t5.start();

    // Thread.yield(); //线程礼让,不一定成功,看cpu心情System.out.println(“=============饺子吃完了,又开始吃包子=============”);}}}}

    class T5 extends Thread{@Overridepublic void run() {for (int i = 1; i <= 20 ; i++) {try {Thread.sleep(500);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("吃了" + i + "饺子 JoinThread----------");}}}线程插队练习package opp1;

    /**

    • 主线程每隔1s,输出hi,一共10次

    • 当输出hi 5 时,启动一个子线程(要求runnable),每隔1s 输出hello ,等该线程输出10次hello后,退出

    • 主线程继续输出

    • 程序结束*/public class demo09 {public static void main(String[] args) throws InterruptedException {T6 t6 = new T6();Thread thread = new Thread(t6);for (int i = 1; i <= 10 ; i++) {System.out.println("hi " + i);if (i == 5){//说明输出了5次 hithread.start();thread.join(); //立即将t6子线程插入到主线程}Thread.sleep(1000); //输出一次hi,让main线程也休眠1s}}}

    class T6 implements Runnable{int count = 0;@Overridepublic void run() {while (true){System.out.println(“hello ” + (++count));

    }守护线程用户现场和守护线程

    用户线程:也叫工作线程,当线程任务执行完毕或通知方式结束守护线程:一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束常见的守护线程:垃圾回收机制package opp1;

    public class demo10 {public static void main(String[] args) throws InterruptedException {T7 t7 = new T7();

    }

    class T7 extends Thread{@Overridepublic void run() {for ( ; ;){ //无限循环try {Thread.sleep(500); //休眠50ms} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(“须弥什么时候开啊,等不及了”);}}}线程7大状态JDK:在 Thread.State 中(操作系统中的几种状态:挂起、就绪、运行、阻塞、终止等几个状态)

    Java 线程基础插图2

    Java 线程基础插图3

    runnable状态是处于可运行状态。

    Java 线程基础插图4

    package opp1;

    public class demo11 {public static void main(String[] args) throws InterruptedException {T8 t8 = new T8();System.out.println(“状态 ” + t8.getState());

    }

    class T8 extends Thread{@Overridepublic void run() {while (true){for (int i = 0; i < 10; i++) {System.out.println("hi" + i);try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}break;}}}线程同步机制在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在任何同一时刻,最多有一个线程访问,以保证数据的完整性也可以这里理解:即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,知道该线程完成操作,其他线程才能对该内存地址进行操作package opp1;

    /**

    • 使用多线程,模拟三个窗口同时售票,每个窗口都会卖出100张票*/

    public class demo05 {public static void main(String[] args) {

    // SellTicket01 sellTicket01 = new SellTicket01();// SellTicket01 sellTicket02 = new SellTicket01();// SellTicket01 sellTicket03 = new SellTicket01();// ////// //会出现超卖的现象,sleep时间越短,就会出现超卖现象// sellTicket01.start();// sellTicket02.start();// sellTicket03.start();

    // SellTicket02 sellTicket021 = new SellTicket02();//// Thread thread = new Thread(sellTicket021);// Thread thread1 = new Thread(sellTicket021);// Thread thread2 = new Thread(sellTicket021);//// thread.start();// thread1.start();// thread2.start();

    }

    //实现接口方法,使用synchronize实现线程同步//因为这里涉及到多个线程共享资源,所以我们使用实现Runnable方式(重要)

    class SellTicket03 implements Runnable{

    }

    //============================================================================================

    class SellTicket01 extends Thread{

    }

    class SellTicket02 implements Runnable{private static int num = 100; //让多个线程共享num@Overridepublic void run() {while (true){if (num <=0){System.out.println(Thread.currentThread().getName() + "售票结束");break;}

    }互斥锁引入对象互斥锁的概念,来保证共享数据的完整性每个对象都对应一个可称为“互斥锁”的标记,这个标记用来保证任一时刻,只能由一个线程访问该对象关键字synchronized 来与对象互斥锁练习,当某个对象用synchronized修饰时,表面该对象在任一时刻只能由一个线程访问同步的局限性:倒置程序的执行效率要降低同步方法(非静态的)的锁可以是this ,也可以是其他对象(要求是同一个对象)同步方法(静态的)的锁为当前类本身package opp1;

    /**

    • 使用多线程,模拟三个窗口同时售票,每个窗口都会卖出100张票*/

    public class demo05 {public static void main(String[] args) {

    // SellTicket01 sellTicket01 = new SellTicket01();// SellTicket01 sellTicket02 = new SellTicket01();// SellTicket01 sellTicket03 = new SellTicket01();// ////// //会出现超卖的现象,sleep时间越短,就会出现超卖现象// sellTicket01.start();// sellTicket02.start();// sellTicket03.start();

    // SellTicket02 sellTicket021 = new SellTicket02();//// Thread thread = new Thread(sellTicket021);// Thread thread1 = new Thread(sellTicket021);// Thread thread2 = new Thread(sellTicket021);//// thread.start();// thread1.start();// thread2.start();

    }

    //实现接口方法,使用synchronize实现线程同步//1. public synchronized void sell() 就是一个同步方法 【非静态】//2. 这时锁在 this对象 【非静态】//3. 也可以在代码块上写synchronized , 如:class SellTicket04,互斥锁还是在this对象 【非静态】

    class SellTicket03 implements Runnable{//因为这里涉及到多个线程共享资源,所以我们使用实现Runnable方式(重要)

    // ///////【同步方法(静态)】的锁为当前类本身!!!// ///////public synchronized static void m1() 的锁加在SellTicket03.class!!!【静态同步方法】// ///////这里的m1()方法使用时static修饰,所以是静态同步方法 【静态同步方法】//// public synchronized static void m1(){//// }//// ///////这里的m2()方法使用static修饰,则底下的synchronized代码块也是【静态同步方法】

    //

    // public static void m2(){// synchronized (SellTicket03.class) {

    // ///////如果在【静态同步方法】中,实现一个同步代码块,synchronized (当前类名.class) !!!// System.out.println(“m2”);// }// }

    }

    //3. 也可以在代码块上写synchronized , 如:class SellTicket04,互斥锁还在this对象 【非静态】

    class SellTicket04 implements Runnable{//因为这里涉及到多个线程共享资源,所以我们使用实现Runnable方式(重要)

    // synchronized (object) { //同步代码块!!!互斥锁还在this对象object 【非静态】if (num <= 0) {System.out.println(Thread.currentThread().getName() + "售票结束");loop = false;return;}

    }

    //===================================================================================================

    class SellTicket01 extends Thread{

    }

    class SellTicket02 implements Runnable{private static int num = 100; //让多个线程共享num@Overridepublic void run() {while (true){if (num <=0){System.out.println(Thread.currentThread().getName() + "售票结束");break;}

    }注意事项

    同步方法如果没有使用static修饰,默认锁对象为this如果同步方法使用static修饰,默认锁对象:当前类.class实现的落地步骤需要分析上锁的代码选择同步代码块或同步方法(尽量使用同步代码块)要求多个线程的锁对象为同一个即可进程死锁多个线程都占用了对方的锁资源,但不肯相让,导致了死索,在编程时一定要避免死锁的发生

    package opp1;

    import javax.swing.plaf.synth.SynthOptionPaneUI;

    public class demo12 {public static void main(String[] args) {//模拟一个死锁现象DeadLockDemo A = new DeadLockDemo(true);DeadLockDemo B = new DeadLockDemo(false);A.setName(“A线程”);B.setName(“B线程”);A.start();B.start();

    }

    class DeadLockDemo extends Thread{static Object o1 = new Object();static Object o2 = new Object();boolean flag;

    }释放锁下面的操作会释放锁

    当前线程的同步方法、同步代码块执行结束当前线程在同步代码块、同步方法遇到break、return当前线程在同步代码块、同步方法中出现未处理的Error 或者Exception,导致异常结束当前线程在同步代码块、同步方法中执行了线程对象的wait( ) 方法,当前线程暂停,并释放锁。下面的操作不会释放锁

    线程执行同步代码块或同步方法时,线程调用sleep、yield方法暂停当前线程的执行,不会释放锁

    线程执行同步代码块时,其他线程调用了该线程的suspend( ) 方法将该线程挂起,该线程不会释放锁。

    提示:应尽量避免使用suspend和resume 来控制线程,这两种方法不再推荐使用。

    作业作业一Java 线程基础插图5

    方法一:

    main先启动TA、TB两个线程

    TA先继续打印随机数,TB 等待键盘输入“Q”指令

    键盘输入“Q”指令,TB 通知TA停止。通过中间变量loop实现通知。

    package opp1;

    import java.util.Random;import java.util.Scanner;

    public class demo13 {public static void main(String[] args) {TA ta = new TA();Thread thread1 = new Thread(ta);thread1.start();TB tb = new TB(ta); //一定要注意tb.start();

    }

    class TA implements Runnable{private boolean loop = true;

    }

    class TB extends Thread{private TA ta;private Scanner scanner = new Scanner(System.in);

    }方法二:进程守护

    作业二Java 线程基础插图6

    package opp1;

    public class demo16 {public static void main(String[] args) {Bank bank = new Bank();Thread t1 = new Thread(bank);Thread t2 = new Thread(bank);t1.setName(“摩拉克斯”);t2.setName(“巴巴托斯”);

    }

    /**

    • 因为这里涉及到多个线程共享资源,所以我们使用实现Runnable方式*/

    class Bank implements Runnable{private int money = 10000;@Overridepublic void run() {/*** 1. 这里使用synchronized实现线程同步* 2. 当多个线程执行到这里时,就会去争夺this对象锁* 3. 哪个线程争夺到 this对象锁,就执行synchronized代码块,执行完后会释放this对象锁* 4. 争夺不到this对象锁,就blocked,准备继续争夺* 5. this对象锁是非公平锁*/while (true){synchronized(this) {if (money < 1000) {System.out.println("余额不足");break;}

    }

  • 0
  • 0
  • 0
  • 24
  • 请登录之后再进行评论

    登录
  • 任务
  • 实时动态
  • 发布
  • 单栏布局 侧栏位置: