c 多线程实现的四种方式

多线程的实现三种⽅式

多线程的实现三种⽅式:

1 继承thread类,重写run⽅法

继承thread⽅法就可以i调⽤thread类的start⽅法,,start⽅法调⽤java natvie start0();

这个是调⽤操作系统的⽅法,start⽅法

package com.cxy;

class Mythread01 extends Thread{

@Override

public void run(){

System.out.println("iii");

}}

public class Mythread {

public static void main(String[] args) {

Mythread01 my = new Mythread01();

my.start();

}

}

2 实现runnable接⼝

接⼝实现是没有start⽅法,但是多线程必须采⽤start⽅法,所以需要调⽤new thread(mythread)

再调⽤start⽅法.

package com.cxy;

import sun.security.krb5.internal.Ticket;

class MyThread implements Runnable{

private Integer ticket=10;

@Override

public void run() {

synchronized (this) {

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

System.out.println("zhgee" + i);

System.out.println(ticket);

ticket--;

if (ticket<0){

break;

}

}

}

}

}

public class RunnableDemo {

public static void main(String[] args) {

MyThread myThread=new MyThread();

多线程的三种实现⽅式及静态代理模式线程、进程与多线程

进程是执⾏程序的⼀次执⾏过程。通常在⼀个进程中可以包含若⼲个线程，⼀个进程中⾄少有⼀个线程。线程是cpu调度和执⾏的单位线程就是独⽴的执⾏路径

在程序运⾏时，即使没有⾃⼰创建线程，后台也会有多个线程，如主线程，gc线程

main()称之为主线程，为系统的⼊⼝，⽤于执⾏整个程序在⼀个进程中，如果开辟了多个线程，线程的运⾏由调度器安排调度，调度是与操作系统紧密相关的，先后顺序是不能⼈为⼲预的对同⼀份资源操作时，会存在资源抢夺的问题，需要加⼊并发控制

线程会带来额外的开销，如cpu调度时间，并发控制开销

每个线程在⾃⼰的⼯作内存交互，内存控制不当会造成数据不⼀致

继承Thread类

⾃定义线程类继承Thread类

重写run()⽅法，编写线程执⾏体

创建线程对象调⽤start()⽅法启动线程

//创建线程⽅式⼀：继承Thread类，重写run()⽅法，调⽤start开启线程

//总结：注意：线程开启不⼀定⽴即执⾏，由cpu调度执⾏

public class TestThread1 extends Thread{

@Override

public void run() {

//run⽅法线程体

for (int i = 0; i < 20; i++) {

System.out.println("我在看代码---"+i);

}

}

public static void main(String[] args) {

//main线程，主线程

//创建⼀个线程对象

TestThread1 testThread1 = new TestThread1();

//调⽤start()⽅法开启线程

testThread1.start();

for (int i = 0; i < 20; i++) {

System.out.println("我在学习多线程---"+i);

}

}

}

====================================================================

- 1 - c++多线程实现方法

C++是一种强大的编程语言，其在多线程编程方面表现出色。为了实现多线程，需要使用C++中的线程库。下面是C++多线程实现方法的详细介绍。

1. 创建线程

要创建一个线程，需要使用C++中的thread类。创建线程的基本语法如下：

```

#include

void myFunction()

{

// do something

}

int main()

{

std::thread t(myFunction); // 创建线程

t.join(); // 等待线程结束

return 0;

}

```

2. 传递参数

如果需要向线程传递参数，可以通过将参数传递给线程构造函数 - 2 - 来实现。

```

#include

void myFunction(int x)

{

// do something with x

}

int main()

{

int x = 42;

std::thread t(myFunction, x); // 向线程传递参数

t.join(); // 等待线程结束

return 0;

}

```

3. 多线程同步

在多线程编程中，同步是一项重要的任务。C++中提供了多种同步机制，如互斥锁和条件变量。

互斥锁是一种保护共享资源的机制。在访问共享资源之前，线程必须获取互斥锁。在完成操作后，线程必须释放互斥锁，以便其他线程可以访问共享资源。

``` - 3 - #include

std::mutex myMutex; // 定义互斥锁

void myFunction()

执行带一个参数的委托函数

#region 执行带一个参数的多线程

Thread mythread = new Thread(new

ParameterizedThreadStart(Calculate));

mythread.IsBackground = true;

mythread.Start(500);

#endregion

private void Calculate(object Max) //带一个参数的委托函数

{

int max = (int)Max;

Stopwatch stopwatch = Stopwatch.StartNew();

for (int i = 0; i < max; i++)

{

Thread.Sleep(5);

}

stopwatch.Stop();

long lSearchTime = stopwatch.ElapsedMilliseconds;

MessageBox.Show(lSearchTime.ToString() + "毫秒");

}

执行带多个参数的委托函数

方式一： 定义一个类,将要传的参数设置为类的属性,然后将参数值赋值给类的属性,将类作为一个参数进行传达,以下代码通过两个参数示例,多个参数一样,代码如下

class MyClass

{

public int Max { get; set; }