JAVA之创建线程的两种方法

叁歲伎倆 2022-05-24 11:22 227阅读 0赞

**前提：**

1：这两种方法都是通过重写run()，在run()方法中实现运行在线程上的代码

2：Runnable相比于Thread更适合多个相同程序代码去处理同一个资源的情况，通常采用Runnable

3：被synchronized 修饰的方法在某一时刻只允许一个线程访问

**多线程**

1.什么是线程

线程是程序执行的一条路径, 一个进程中可以包含多条线程

多线程并发执行可以提高程序的效率, 可以同时完成多项工作

2. 多线程并行和并发的区别

1) 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)

2) 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。

3. Java程序运行原理

Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个“主线程” ，然后主线程去调用某个类的main 方法。

4. JVM的启动是多线程的吗

JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

**多线程程序实现的方式**

1.继承Thread

\* 定义类继承Thread

\* 重写run方法

\* 把新线程要做的事写在run方法中

\* 创建线程对象

\* 开启新线程, 内部会自动执行run方法

classMyThread extends Thread \{                           //1,定义类继承Thread

public voidrun() \{                    //2,重写run方法

for(inti = 0; i < 3000; i++) \{     //3,将要执行的代码,写在run方法中

System.out.println("threadrunning");

main:

MyThreadmt = new MyThread();           //4,创建自定义类的对象

mt.start();        //5,开启线程

for(inti = 0; i < 3000; i++) \{

System.out.println("main");

2.实现Runnable

classMyRunnable implements Runnable \{    //1,自定义类实现Runnable接口

@Override

public voidrun() \{            //2,重写run方法

for(inti = 0; i < 3000; i++) \{     //3,将要执行的代码,写在run方法中

System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");

main:

MyRunnablemr = new MyRunnable();           //4,创建自定义类对象

//Runnabletarget = new MyRunnable();

Thread t= new Thread(mr);            //5,将其当作参数传递给Thread的构造函数

t.start();                                           //6,开启线程

for(inti = 0; i < 3000; i++) \{

System.out.println("bb");

**两种方式的区别**

\* 继承Thread

\* 好处是:可以直接使用Thread类中的方法,代码简单

\* 弊端是:如果已经有了父类,就不能用这种方法

\* 实现Runnable接口

\* 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的

\* 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

**匿名内部类**实现线程的两种方式

1. 继承Thread类

new Thread() \{         //1,new 类()\{\}继承这个类

public void run() \{            //2,重写run方法

for(int i = 0; i< 3000; i++) \{     //3,将要执行的代码,写在run方法中

System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");

\}.start();

2. 实现Runnable接口

new Thread(new Runnable()\{         //1,new 接口()\{\}实现这个接口

public void run() \{            //2,重写run方法

for(int i = 0; i< 3000; i++) \{     //3,将要执行的代码,写在run方法中

System.out.println("bb");

\}).start();

**常用方法：**

1. 获取名字和设置名字

\* 1).获取名字

\* 通过getName()方法获取线程对象的名字

\* 2).设置名字

\* setName()方法

\* 通过构造函数可以传入String类型的名字

2. 获取当前线程的对象

在Runnable中不能直接使用this.getName(),可以先获取当前正在执行的线程

Thread.currentThread(),主线程也可以获取

3. 休眠线程

\*Thread.sleep(毫秒,纳秒), windows支持毫秒

\* 使用过程的会抛出异常，必须trycatch。

4. 礼让线程

\* yield让出cpu

5. 加入线程

\*join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续

\*join(int), 可以等待指定的毫秒之后继续

6. 设置线程的优先级

\*setPriority()设置线程的优先级

**同步代码块**

\* 1.什么情况下需要同步

\* 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.

\* 如果两段代码是同步的, 那么同一时间只能执行一段,在一段代码没执行结束之前, 不会执行另外一段代码.

\* 2.同步代码块

\* 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块

\* 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

以火车票售票问题为例：

1. privatestatic int ticket = 10;   车票是静态的

2. 同步锁问题：

1）synchronized(this) ：new出来四个线程代表的是4个this，不是一个this。

2) Objectlock = new Object();   synchronized (obj)；4个线程，每个线程对象都有自己的成员变量lock，因此可以加static，所有对象共享同一个锁。

3. 处理：

1）synchronized(MyTicket.class),锁的是该类。

2） privatestatic Object lock = new Object();   静态锁。

**同步方法：**

\* 使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的

//非静态的同步方法的锁对象是?

//答:非静态的同步方法的锁对象是this

//静态的同步方法的锁对象是什么?

//是该类的字节码对象

**死锁**

\* 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁

\* 尽量不要嵌套使用

以前的线程安全的类

Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)

\* Vector是线程安全的,ArrayList是线程不安全的

\* StringBuffer是线程安全的,StringBuilder是线程不安全的

\* Hashtable是线程安全的,HashMap是线程不安全的

**继承Thread类创建多线程**

package rjxy;  
  
/\*  
 \* 通过继承Thread类的方式创建两个线程，在Thread构造方法中指定线程的名字，并将这两个线程的名字打印出来。

\*/

public class Thread1 \{  
public static void main(String\[\] args) \{  
MyThread t1=new MyThread("我是线程1");  
MyThread t2=new MyThread("我是线程2");  
t1.start();  
t2.start();  
\}  
\}  
  
  
class MyThread extends Thread\{  
  
public MyThread() \{  
super();  
\}  
  
public MyThread(String name) \{  
super(name);  
\}  
  
public void run()\{  
for (int i = 0; i <10; i++) \{  
System.out.println(this.getName());  
\}  
\}

**实现Runnable接口创建多线程**

package rjxy;  
  
public class Thread2 \{  
/\*  
 \* 通过实现Runnable接口的方式创建一个线程，要求main线程打印100次“main”，新线程打印50次“new”  
 \*/  
public static void main(String\[\] args) \{  
 MyRunnable mr=new MyRunnable();  
 Thread t1=new Thread(mr);  
 t1.start();  
   
 for (int i = 0; i < 100; i++) \{  
System.out.println("main");  
\}  
\}  
\}  
  
class MyRunnable implements Runnable\{  
  
@Override  
public void run() \{  
 for (int i = 0; i <50; i++) \{  
System.out.println("new");  
\}  
  
\}

**一个栗子**

package rjxy;  
  
public class Thread3 \{   
/\*  
 \* 模拟3个来时同时分发80份笔记，每个老师相当于一个线程。  
 \*/  
public static void main(String\[\] args) \{  
MyRunnable\_paper mrp=new MyRunnable\_paper();  
//新建是三个线程  
new Thread(mrp,"赵老师").start();  
new Thread(mrp,"张老师").start();  
new Thread(mrp,"李老师").start();  
\}  
  
  
\}  
class MyRunnable\_paper implements Runnable\{  
private static int num=80;  
  
@Override  
public void run() \{  
while(true)\{  
papers();  
\}  
\}  
public synchronized void papers()\{  
   
if (num>0) \{  
System.out.println(Thread.currentThread().getName()+"正在发"+num--);  
\}else\{  
System.exit(0);  
\}  
  
\}

第二个栗子

package rjxy;

public class Thread4 \{  
  
// \* 编写10个线程，第一个线程从1加到10， 第2个线程从11加到20，......第10个线程从91加到100，最后把10个线程的结果相加。  
  
public static void main(String\[\] args) throws InterruptedException \{  
Thread \[\] mys=new Thread\[10\];  
//多态  
for (int i = 0; i < 10; i++) \{  
mys\[i\]=new MyThread\_add(i\*10+1);  
mys\[i\].start();  
\}  
for (int i = 0; i < 10; i++) \{  
mys\[i\].join();  
\}

System.out.println(MyThread\_add.getSum());

\}  
  
  
\}  
class  MyThread\_add extends Thread\{  
private int startNum;  
private static int sum=0;  
  
public MyThread\_add() \{  
super();  
// TODO Auto-generated constructor stub  
\}  
//初始化开始值  
public MyThread\_add(int startNum) \{  
this.startNum=startNum;  
\}  
  
public  void run()\{  
int sum=0;  
for (int i = 0; i <10; i++) \{  
sum+=startNum+i;  
\}  
add(sum);  
\}  
public synchronized void add(int num)\{   
sum+=num;  
\}  
public static int getSum()\{  
return sum;  
\}

**第三个栗子**

package yu;  
  
//窗口售票的栗子  
  
  
public class Main \{  
public static void main(String\[\] args) \{  
  
MyRunnable task =new MyRunnable();//创建线程的任务类对象  
  
new Thread(task,"窗口1").start();//创建线程并起名  
new Thread(task,"窗口2").start();//创建线程并起名  
new Thread(task,"窗口3").start();//创建线程并起名  
new Thread(task,"窗口4").start();//创建线程并起名  
  
\}  
\}  
  
  
class MyRunnable implements Runnable\{  
static private int tickets=500;//票数  
  
@Override  
public void run() \{  
while(true) \{//无数次调用直到system.exit(0)  
sendTicket();  
\}  
\}  
  
//定义售票的方法，该方法某一时刻允许一个线程访问  
public synchronized void sendTicket() \{   
try \{  
Thread.sleep(10);//线程休眠10秒  
\} catch (InterruptedException e) \{  
// TODO Auto-generated catch block  
e.printStackTrace();  
\}  
//售票  
if (tickets>0) \{  
System.out.println(Thread.currentThread().getName()+"---卖出去的票"+tickets--);  
\}else \{  
System.exit(0);  
\}  
\}