多线程基础知识

雨点打透心脏的1/2处 2023-10-11 00:24 68阅读 0赞

**(****1** **)****传统****使****用****类****T****h****rea****d****和****接****口****Run****na****bl****e****实现**

**1****.****在****T****h****rea****d****子****类****覆****盖****的****r****u****n****方****法****中****编****写****运****行****代****码**

**方式****一**

new Thread()\{

@Override

public void run()\{

while(true)\{

try \{

Thread.sleep(2000);

\} catch (InterruptedException e) \{

e.printStackTrace();

\}.start();

**2****.****在传****递****给****T****hr****e****a****d****对****象****的****Runn****a****b****l****e****对****象****的****r****u****n****方****法中****编****写****代码**

new Thread(new Runnable()\{

public void run()\{

while(true)\{

try \{

Thread.sleep(2000);

\} catch (InterruptedException e) \{

e.printStackTrace();

System.out.println(Thread.currentThread().getName());

\}).start();

**3****.****总****结**

查看Thread类的run()方法的源代码，可以看到其实这两种方式都是在调用Thread对象的run方法，如果Thread

类的 run 方法没有被覆盖，并且为该 Thread 对象设置了一个 Runnable 对象，该 run 方法会调用 Runnable 对象的

run方法

/\*\*

\* If this thread was constructed using a separate

\* <code>Runnable</code> run object, then that   
\* <code>Runnable</code> object's <code>run</code> method is called; \* otherwise, this method does nothing and returns.

\* <p>  
\* Subclasses of <code>Thread</code> should override this method.

\* @see \#start()

\* @see \#stop()

\* @see \#Thread(ThreadGroup, Runnable, String)

\*/

@Override

public void run() \{

if (target != null) \{

target.run();

**(****2** **)****定实****现****时****器****Ti****m****e****r****和****Ti****m****er****T****as****k**

Timer 在实际开发中应用场景不多，一般来说都会用其他第三方库来实现。但有时会在一些面试题中出现。

下面我们就针对一道面试题来使用Timer定时类。

**1****.****请模****拟****写****出****双****重****定****时****器****（****面试****题）**

要求：使用定时器,间隔4秒执行一次，再间隔2秒执行一次，以此类推执行。

class TimerTastCus extends TimerTask\{

@Override

public void run() \{

count = (count +1)%2;

System.err.println("Boob boom ");

new Timer().schedule(new TimerTastCus(), 2000+2000\*count);

Timer timer = new Timer();

timer.schedule(new TimerTastCus(), 2000+2000\*count);

while (true) \{

System.out.println(new Date().getSeconds());

try \{

Thread.sleep(1000);

\} catch (InterruptedException e) \{

// TODO Auto-generated catch block

e.printStackTrace();

//PS：下面的代码中的count变量中

//此参数要使用在你匿名内部类中，使用final修饰就无法对其值进行修改，

//只能改为静态变量

private static volatile int count = 0;

**(****3** **)****线程****互****斥****与****同****步**

在引入多线程后，由于线程执行的异步性，会给系统造成混乱，特别是在急用临界资源时，如多个线程急用同一台

打印机，会使打印结果交织在一起，难于区分。当多个线程急用共享变量，表格，链表时，可能会导致数据处理出错，

因此线程同步的主要任务是使并发执行的各线程之间能够有效的共享资源和相互合作，从而使程序的执行具有可再现性。

当线程并发执行时，由于资源共享和线程协作，使用线程之间会存在以下两种制约关系。

1. 间接相互制约。一个系统中的多个线程必然要共享某种系统资源，如共享 CPU，共享 I/O 设备，所谓间接相

互制约即源于这种资源共享，打印机就是最好的例子，线程A在使用打印机时，其它线程都要等待。

2. 直接相互制约。这种制约主要是因为线程之间的合作，如有线程 A 将计算结果提供给线程 B 作进一步处理，

那么线程B在线程A将数据送达之前都将处于阻塞状态。

间接相互制约可以称为**互****斥**，直接相互制约可以称为**同****步**，对于互斥可以这样理解，线程 A 和线程 B 互斥访问某

个资源则它们之间就会产个顺序问题——要么线程A 等待线程B 操作完毕，要么线程 B等待线程操作完毕，这其实就

是线程的同步了。因此同步包括互斥，互斥其实是一种特殊的同步。

下面我们通过一道面试题来体会线程的交互。

要求：子线程运行执行10次后，主线程再运行5次。这样交替执行三遍

public static void main(String\[\] args) \{

final Bussiness bussiness = new Bussiness();

//子线程

new Thread(new Runnable() \{

@Override

public void run() \{

for (int i = 0; i < 3; i++) \{

bussiness.subMethod();

\}).start();

//主线程

for (int i = 0; i < 3; i++) \{

bussiness.mainMethod();

class Bussiness \{

private boolean subFlag = true;

public synchronized void mainMethod() \{

while (subFlag) \{

try \{

wait();

\} catch (InterruptedException e) \{

e.printStackTrace();

for (int i = 0; i < 5; i++) \{

System.out.println(Thread.currentThread().getName()

\+ " : main thread running loop count \-- " + i);

try \{

Thread.sleep(1000);

\} catch (InterruptedException e) \{

e.printStackTrace();

subFlag = true;

notify();

public synchronized void subMethod() \{

while (!subFlag) \{

try \{

wait();

\} catch (InterruptedException e) \{

e.printStackTrace();

for (int i = 0; i < 10; i++) \{

System.err.println(Thread.currentThread().getName()

\+ " : sub thread running loop count \-- " + i);

try \{

Thread.sleep(1000);

\} catch (InterruptedException e) \{

e.printStackTrace();

subFlag = false;

notify();

**(****4** **)****线程****局****部****变****量****T****hr****e****a****d****Lo****c****a****l**

l ThreadLocal 的作用和目的：用于实现线程内的数据共享，即对于相同的程序代码，多个模块在同一个线程中运行时要共享一份数据，而在另外线程中运行时又共享另外一份数据。

l 每个线程调用全局 ThreadLocal 对象的 set 方法，在 set 方法中，首先根据当前线程获取当前线程的ThreadLocalMap对象，然后往这个map中插入一条记录，key其实是ThreadLocal对象，value是各自的set方法传进去的值。也就是每个线程其实都有一份自己独享的ThreadLocalMap对象，该对象的Key是ThreadLocal对象，值是用户设置的具体值。在线程结束时可以调用ThreadLocal.remove()方法，这样会更快释放内存，不调用也可以，因为线程结束后也可以自动释放相关的ThreadLocal变量。

l ThreadLocal的应用场景：

➢ 订单处理包含一系列操作：减少库存量、增加一条流水台账、修改总账，这几个操作要在同一个事务中完成，通常也即同一个线程中进行处理，如果累加公司应收款的操作失败了，则应该把前面的操作回滚，否则，提交所有操作，这要求这些操作使用相同的数据库连接对象，而这些操作的代码分别位于不同的模块类中。

➢ 银行转账包含一系列操作： 把转出帐户的余额减少，把转入帐户的余额增加，这两个操作要在同一个事务中完成，它们必须使用相同的数据库连接对象，转入和转出操作的代码分别是两个不同的帐户对象的方法。

➢ 例如Strut2的ActionContext，同一段代码被不同的线程调用运行时，该代码操作的数据是每个线程各自的状态和数据，对于不同的线程来说，getContext方法拿到的对象都不相同，对同一个线程来说，不管调用 getContext 方法多少次和在哪个模块中 getContext 方法，拿到的都是同一个。