java创建线程并设置创建最大线程数 java创建线程代码

方法一：继承于Thread类

步骤：

1. 创建一个继承于Thread类的子类
2. 重写Thread类的run()，将此线程执行的操作声明在run()中，该run方法的方法体就代表了线程要完成的任务
3. 创建Thread类的子类的对象，即创建了线程对象
4. 通过此对象调用start()执行线程

示例代码如下：

public class MyThread extends Thread {
	public void run() {
		for(int i=0;i<100;i++) {
			if(i%2==1) {
				System.out.println(Thread.currentThread().getName()+":"+i);
			}
		}
	}
}
public class Threadtest {
	public static void main(String[] args) {
		//创建Thread类的子类对象
		MyThread t1=new MyThread();
		//通过此对象调用start()：1.启动当前线程2.调用当前线程的run()
		t1.start();
		//重新创建一个线程对象
		MyThread t2=new MyThread();
		t2.start();
		//如下操作是在main线程中执行的
		for(int i=0;i<100;i++) {
			if(i%2==1) {
				System.out.println(Thread.currentThread().getName()+":"+i+"*****main()*****");
			}
		}
	}
}

注意事项：

1. 不能通过直接调用run()的方式启动线程，这种方式只是简单调用方法，并未新开线程
2. 再启动一个线程，执行相同的任务，不可以还让已经start()的线程去执行，会报IllegalThreadStateException

方式二：实现Runnable接口

步骤：

1. 创建一个实现了Runnable接口的类
2. 实现类去实现Runnable中的抽象方法：run()
3. 创建实现类对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5. 通过Thread类的对象调用start()

• （1）启动线程
• （2）调用当前线程的run()->调用了Runnable类型的target的run()

示例代码如下：

public class MyThread implements Runnable {
	public void run() {
		for(int i=0;i<100;i++) {
			if(i%2==1) {
				System.out.println(Thread.currentThread().getName()+":"+i);
			}
		}
	}
}
public class Threadtest {
	public static void main(String[] args) {
		//创建实现类的对象
		MyThread mthread=new MyThread();
		//将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
		Thread t1=new Thread(mthread);
		t1.setName("线程1");
		//通过Thread类的对象调用start()：1.启动线程2.调用当前线程的run()->调用了Runnable类型的target的run()
		t1.start();
		//再启动一个线程
		Thread t2=new Thread(mthread);
		t2.setName("线程2");
		t2.start();
		
	}
}

方式一和方式二的比较：

开发中优先选择实现Runnable接口的方式，原因如下：

• 实现的方式没有类的单继承性的局限
• 实现的方式更适合来处理多个线程有共享数据的情况

相同点：

• 两种方式都需要重写run()，将线程要执行的逻辑声明在run()中

方式三：实现Callable接口

步骤：

1. 创建一个实现Callable的实现类
2. 实现call方法，将此线程需要执行的操作声明在call()中
3. 创建Callable接口实现类的对象
4. 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
6. 获取Callable中call方法的返回值

实现Callable接口的方式创建线程的强大之处：

• call()可以有返回值的
• call()可以抛出异常，被外面的操作捕获，获取异常的信息
• Callable是支持泛型的

示例代码如下：

public class MyThread implements Callable {
	public Object call() {
		int sum=0;
		for(int i=0;i<100;i++) {
			if(i%2==1) {
				System.out.println(Thread.currentThread().getName()+":"+i);
				sum+=i;
			}
		}
		return sum;
	}
}
public class Threadtest {
	public static void main(String[] args) {
		//创建Callable接口的实现类的对象
		MyThread mthread=new MyThread();
		//将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
		FutureTask futureTask=new FutureTask(mthread);
		//将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
		Thread t1=new Thread(futureTask);
		t1.start();
	}
}

示例代码2：

public class MyThread implements Callable<Integer> {
	public Integer call() {
		System.out.println("Callable come in!");
		return 2048;
	}
}
public class Threadtest {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建Callable接口的实现类的对象
		MyThread mthread=new MyThread();
		//将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
		FutureTask<Integer> futureTask=new FutureTask<Integer>(mthread);
		//将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
		Thread t1=new Thread(futureTask);
		t1.start();
		int b=0;
		//要求获得Callable线程的计算结果，如果没有计算完成就要去强求，会导致堵塞，直到计算完成
		while(!futureTask.isDone()) {
			b=futureTask.get();
		}
		System.out.println(b);
	}
}
//运行结果：
//Callable come in!
//2048

方式四：使用线程池

线程池的好处：

1. 提高响应速度（减少了创建新线程的时间）
2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3. 便于线程管理

核心参数：

• corePoolSize：核心池的大小
• maximumPoolSize：最大线程数
• keepAliveTime：线程没有任务时最多保持多长时间后会终止

步骤：

1. 以方式二或方式三创建好实现了Runnable接口的类或实现Callable的实现类
2. 实现run()或call()方法
3. 创建线程池
4. 调用线程池的execute方法执行某个线程，参数是之前实现Runnable或Callable接口

示例代码如下：

public class MyThread implements Runnable {
	public void run() {
		for(int i=0;i<100;i++) {
			if(i%2==1) {
				System.out.println(Thread.currentThread().getName()+":"+i);
			}
		}
	}
}
public class numThread implements Runnable {
	public void run() {
		for(int i=0;i<100;i++) {
			if(i%2==0) {
				System.out.println(Thread.currentThread().getName()+":"+i);
			}
		}
	}
}
public class Threadtest {
	public static void main(String[] args)  {
		//提供指定线程数量的线程池
		ExecutorService service=Executors.newFixedThreadPool(10);
		System.out.println(service.getClass());
		service.execute(new MyThread());//适用于Runnable
		service.execute(new numThread());
		//service.submit();适用于Callable
		//关闭连接池
		service.shutdown();
	}
}

方式五：使用匿名类

Thread t1=new Thread(new Runnable() {
	public void run() {
		System.out.println("子线程开始启动......");
		for(int i=0;i<20;i++) {
			System.out.println(i);
		}
	}
});
t1.start();