方式1:
>继承于Thread类
> 创建一个继承于Thead类的子类
>重写Thread类的run方法
>创建Thread的对象
>通过该对象调用start()
class A extends Thread{
@Override
public void run() {
for (int i= 1 ;i<=100; i++){
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName()+" : "+i);
}
}
}
}
//在main方法中直接调用start()方法;
public static void main(String[] args) {
A a = new A();
a.start();
}
方式2:
>创建一个实现类实现Runnable的接口
>实现类实现Runnable的run()方法
>创建实现类的对象
>将该对象作为参数放到Thread的构造器中创建Thead对象
>通过Thread类的对象调用start()方法;
class B implements Runnable{
@Override
public void run() {
for (int i= 1 ;i<=100; i++){
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName()+" : "+i);
}
}
}
}
//先要创建实现类的对象,然后把该对象放进Thead()的构造器中,再调用start()方法
public static void main(String[] args) {
B b = new B();
Thread thread = new Thread(b);
thread.start();
}
方式3:
>实现Callable接口
>实现call方法,将线程要执行的操作声明在call方法中
>创建Callable接口实现类的对象
>将此Callable接口实现了的对象作为参数传到FutureTask构造器中,创建FutureTask的对象
>将FutureTask的对象放到Thread的构造器中并调用start方法
class C implements Callable{
@Override
public Object call() throws Exception {
int sum = 0;
for (int i= 1 ;i<=100; i++){
sum += i;
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName()+" : "+i);
}
}
return sum;
}
}
//先要创建实现类的对象,然后将该对象放到FutureTask的构造器中生成FutureTask的对象,再将这个对象放到Thread的构造器中再调用start()方法
public static void main(String[] args) {
C c = new C();
FutureTask task = new FutureTask(c);
Thread thread1 = new Thread(task);
thread1.start();
try {
Object o = task.get();
System.out.println(o+"***********************");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
方式4:线程池
提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中,可以避免频繁创建销毁,实现重复利用。
好处:
一、提高响应效率
二、降低资源消耗
三、便于线程管理
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
executorService.execute(new B());//适用于实现Runnable接口的
executorService.execute(new A());//也适用于继承Thread类的
executorService.submit(new B());//适用于实现Runnable接口的
executorService.submit(new C());//适用于实现Callable接口的
}
方式二和方式三的区别:
实现Callable接口比实现Runnable接口创建的功能更加强大
一、相比run()方法,Callable的call方法可以带有返回值,需要借助FutureTask类,获取返回结果。
二、可以抛出异常,方便捕获错误
三、支持泛型
希望该文章对你们有帮助哈,有帮到你们的麻烦点个赞哈,有兴趣的朋友可以关注一下公众号,公众号上会发布一些最近行业常用的技术,还有一些自己见解的文章。