java多线程有几种实现方法,都是什么?同步有几种实现方法，都是什么；

java创建多线程有两种方式：
第一种方式是继承Tread

步骤：
1，定义类继承Thread。
2，复写Thread类中的run方法。
        目的：将自定义代码存储在run方法。线程要运行的代码都在该run方法中。

3，调用线程的start方法，
        该方法两个作用：启动线程，调用run方法。


第二种方式：实现Runable接口

步骤：
1，定义类实现Runnable接口
2，覆盖Runnable接口中的run方法。
        将线程要运行的代码存放在该run方法中。

3，通过Thread类建立线程对象。
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
        为什么要将Runnable接口的子类对象传递给Thread的构造函数。
        因为，自定义的run方法所属的对象是Runnable接口的子类对象。
        所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。


5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。



实现方式和继承方式的区别

实现方式好处：避免了单继承的局限性。
在定义线程时，建立使用实现方式。

两种方式区别：
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable，线程代码存在接口的子类的run方法。


还有一个是JDK新的多线程方式，线程池概念：

/*
创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
它有四个参数，第一个参数是要执行的线程代码，类似于实现Runnable方法，覆盖run方法
第二个参数是首次执行的延迟时间时间
第三个参数定义经过多长时间后再次执行
第四个参数定义的是执行上两个参数的单位
*/

Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                                new Runnable(){
                                        public void run(){                                       
                                        }
                                },
                                0,
                                5,
                                TimeUnit.SECONDS);

Java多线程有两种实现方法。
一种是：

new Thread() {
                        public void run() {
                                for (int i = 0; i < 3; i++) {
                                        p.print1();
                                }
                        }
                }.start();        // 启动新线程
这是直接继承Thread类，重写run方法，然后创建一个线程。
一种是：
                new Thread(new Runnable() {
                        public void run() {
                                for(int i = 0; i < 3; i++) {
                                        p.print2();
                                }
                        }
                }).start();        // 启动新线程
这是实现Runnable接口，重写Runnable的run方法。然后把该实现类传递给Thread的构造函数创建一个线程。

同步的实现方法有同步代码块和同步方法
1.        同步代码块
synchronized(Object obj) {
…
}
        锁是obj
2.        同步方法
synchronized 返回值 方法名(参数列表) {
}
锁是this（调用当前方法的实例对象）

创建线程的第一种方式：继承Thread类

1 步骤：

定义类继承Thread

复写Thread类中的run方法

调用线程的start方法

该方法两个作用：启动线程，调用run方法

第二种方式：实现Runable接口

1. 步骤：

定义类实现Runnable接口

覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中

通过Thread类建立线程对象

将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数

调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

实现方式和继承方式的区别

实现方式好处：避免了单继承的局限性。

在定义线程时，建立使用实现方式。

两种方式区别：

继承Thread:线程代码存放Thread子类run方法中。

实现Runnable，线程代码存在接口的子类的run方法。

同步有两种表现形式：

一种就是同步代码块。同步代码块中的锁可以是任意的对象，用Object obj = new Object();可以作为同步代码块中的锁。
synchronized（对象）  //对象可以使任意的对象。

{

需要被同步的语句。

}
另一种就是同步函数。就是在函数中加入同步代码块的关键字synchronized，这样就能使该函数变为同步函数。

函数肯定被对象调用，代表调用函数对象的引用就是this，也就是说同步函数使用的锁是this。

同步函数和同步代码块有什么区别呢？

1、同步函数比同步代码块写法简单

2、同步函数使用的锁是this，同步代码块使用的锁是任意指定的对象

   建议开发时，使用同步代码块，尤其是需要不同锁时

以上是JDK1.5之前使用同步代码块和同步函数来解决多线程中的安全性问题
但在JDK1.5中，JDK出现了新的借口和类那就是Lock和Condition
Lock：比同步函数和同步代码块要好

原来在同步中，锁和监视器是同一个对象（在同步里）

现在，升级后，锁是一个单独的对象。而且将监视器的方法也单独封装到了一个对象中， 这个对象就是升级后的Condition

升级后，都进行了单独的封装，锁被封装成了Lock对象，监视器方法被封装到了 Condition对象（监视器）中

Lock替代了同步，Condition代替了Objcet中的监视器方法

Condition中提供了监视器的方法：await（）.singal（）.signalAl（）

以上就是在看完毕老师视频是的一些总结，希望对你有所帮助！！！{:soso_e100:}

问题已解决