黑马程序员_java01_多线程

最新推荐文章于 2022-10-17 17:18:37 发布

Enjoy_db

最新推荐文章于 2022-10-17 17:18:37 发布

阅读量335

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/u010414231/article/details/43227405

版权

java基础专栏收录该内容

1 篇文章 0 订阅

订阅专栏

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1，线程与进程的区别。

进程属于一个独立的运行程序，线程是程序里面的一个分支。许多个线程组成一个程序的运行。

2. java实现线程的方式有两种一是实现Runnable接口实现run方法，二是继承Thread类

1. 实现Runnable接口：

在java语言中不能实现多继承，但是可以实现多实现。使用Runnable接口可以避免一个类同时继承别的类，又要实现多线程的方式。在开发过程中推荐使用Runnable。

public class TestMitiThread1 implements Runnable {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + " 线程运行开始!");
        TestMitiThread1 test = new TestMitiThread1();
        Thread thread1 = new Thread(test);
        Thread thread2 = new Thread(test);
        thread1.start();
        thread2.start();
        System.out.println(Thread.currentThread().getName() + " 线程运行结束!");
    }
 
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 线程运行开始!");
        for (int i = 0; i < 10; i++) {
            System.out.println(i + " " + Thread.currentThread().getName());
            try {
                Thread.sleep((int) Math.random() * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " 线程运行结束!");
    }
}

运行结果：

main 线程运行开始!

Thread-0 线程运行开始!

main 线程运行结束!

0 Thread-0

Thread-1 线程运行开始!

0 Thread-1

1 Thread-1

1 Thread-0

2 Thread-0

2 Thread-1

3 Thread-0

3 Thread-1

4 Thread-0

4 Thread-1

5 Thread-0

6 Thread-0

5 Thread-1

7 Thread-0

8 Thread-0

6 Thread-1

9 Thread-0

7 Thread-1

Thread-0 线程运行结束!

8 Thread-1

9 Thread-1

Thread-1 线程运行结束!

说明：

TestMitiThread1类通过实现Runnable接口，使得该类有了多线程类的特征。run（）方法是多线程程序的一个约定。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

2.继承Thread类实现多线程。

在java中实现Thread类并复写run（）方法，实现多线程。

public class TestMitiThread2 extends Thread{
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + " 线程运行开始!");
        TestMitiThread1 test = new TestMitiThread1();
        Thread thread1 = new Thread(test);
        Thread thread2 = new Thread(test);
        thread1.start();
        thread2.start();
        System.out.println(Thread.currentThread().getName() + " 线程运行结束!");
    }
 
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 线程运行开始!");
        for (int i = 0; i < 10; i++) {
            System.out.println(i + " " + Thread.currentThread().getName());
            try {
                Thread.sleep((int) Math.random() * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " 线程运行结束!");
    }
}

运行结果：

main 线程运行开始!

Thread-0 线程运行开始!

main 线程运行结束!

0 Thread-0

Thread-1 线程运行开始!

0 Thread-1

1 Thread-1

1 Thread-0

2 Thread-0

2 Thread-1

3 Thread-0

3 Thread-1

4 Thread-0

4 Thread-1

5 Thread-0

6 Thread-0

5 Thread-1

7 Thread-0

8 Thread-0

6 Thread-1

9 Thread-0

7 Thread-1

Thread-0 线程运行结束!

8 Thread-1

9 Thread-1

Thread-1 线程运行结束!

程序说明：

实现多线程的两种方法都差不多一样的，都必须有run（）方法。在run方法里面对线程的描述。

3.多线程之间的通讯

在多线程中线程有以下几种状态。

1. 新建状态（New）：新创建了一个线程对象。
2. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5. 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

在新建状态下用户可以使用start（）方法使线程进入就绪状态。在就绪状态线程获得了cpu执行权，线程正式开始运行。

在线程运行过程中用户可以通过sellp（1000）方法使线程休眠使用wait()使线程进入等待状态。使用notify()唤醒线程。使线程进入抢夺线程的队列当中。线程休眠时线程进入等待池中，线程等待时线程进入等待池中。

线程的同步

在多个线程共享同一条数据时会产生数据的读取错误。此时就要使用线程锁来控制线程读取数据的规则。使用synchronized（）｛｝封装需要被同步的代码。注意：synchronized不能封装run方法。这样的话就时多线程变成了单线程。

synchronized同步的锁必须是唯一对象。不然的话会影响同步效果。下面使用两个线程共同卖同一种票的例子来分析这个同步问题

public class ThreadDemo implements Runnable{
private  int  piao;
public static void main (String[] args){
piao p=new piao();
ThreadDemo ThreadDemo=new ThreadDemo(p);//想要共享同一个数据必须使用同一个对象。现在只是对象，根本就不是线程。

new Thread(ThreadDemo).start();//创建线程，使用同一个对象。
new Thread(ThreadDemo).start();
}
public ThreadDemo(){

}
public ThreadDemo(piao p){
this.piao=p.piao;
}
public void run(){
while(true){
synchronized(this){//使用线程锁控制共享的数据不被多个线程所共同访问。
if(piao>0){
piao--;
System.out.println(Thread.currentThread().getName()+"------------------->"+piao);
}else{
break;
}
}
try{
Thread.sleep(1000);
}catch(InterruptedException  e){
}
}
}
}
class piao {
public  int piao=100;
}

Enjoy_db

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员_java01_多线程

1，线程与进程的区别。进程属于一个独立的运行程序，线程是程序里面的一个分支。许多个线程组成一个程序的运行。2. java实现线程的方式有两种一是实现Runnable接口实现run方法，二是继承Thread类 1. 实现Runnable接口：在java语言中不能实现多继承，但是可以实现多实现。使用Runnable接口可以避免一个类同时继承别的类，又要实现多线程的
复制链接

扫一扫