java多线程有几种实现方法,都是什么?同步有几种实java中多线程的实现方法有两种：1.直接继承thread类；2.实现runnable接口；同步的实现方法有五种：1.同步方法；2.同步代码块；3.使用特殊域变量(volatile)实现线程同步；4.使用重入锁实现线程同步；5.使用局部变量实现线程同步 。
 
JAVA多线程有哪几种实现方式
 
JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。
 

 
继承Thread类实现多线程继承Thread类
 
java多线程有几种创建方法？？？
 
楼主您好，很高兴为您解答，java里面创建多线程有2种方法 第一种是继承Thread类，然后实现它的run方法，例如： public class mythread extends Thread { public class run(){您的代码} } 第二种就是实现 Runnable这个接口。
 
java多线程都有几种方式实现？？
 
有三种： (1)继承Thread类，重写run函数 创建： class xx extends Thread{ public void run(){ Thread.sleep(1000)//线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源 }} 开启线程： 对象.start()//启动线程，run函数运行 (2)实现Runnab
 
java中线程同步的几种方法
 
线程同步主要有以下种方法(示例中是实现计数的功能)：
 
同步方法，即使用synchronized关键字修饰方法，例如： public synchronized void add(int c){...}
 
同步代码块，即有synchronized关键字修饰的语句块，例如： public void addAndGet(in
 
java中线程的run()方法
 
两种方法的区别 1) start： 用 start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的 start()方法来启动一个线程，这时此线程处于就绪(可运行)状态，并没有运行。
 
为什么Java中实现多线程的方式有两种
 
java创建线程的方式有三种 第一种是继承Thread类 实现方法run() 不可以抛异常 无返回值 第二种是实现Runnable接口 实现方法run() 不可以抛异常 无返回值 第三种是实现Callable接口,接口中要覆盖的方法是 public call() 注意:此方法可以抛异常,而
 
java实现多线程的两种方法
 
Thread t1=new Thread(){ public void run(){ System.out.println("第一种方法"); } }; t1.start(); Thread t2=new Thread(new Runnable() { public void run() { System.out.println("第二种方法，可实现同类下各线程数据共享"); } }); t2.star
 
java多线程，如何实现两个不同的方法
 
继承Thread类，写两个方法实现两个线程，一个方法实现每次i+1，另一个方class test1 implements Runnable{ @Override public void run() { // TODO Auto-generated method stub } public int add(int i){ return i+1; } public int del(int j){ return j-1; } } class test2 extends Thread{ @Override public void r
 
Java多线程两种实现方式的比较实现多线程的两种方式，一种是继承Thread类，一种是实现Runnable接口，因为Runnable是一个接口，没有定义start()方法，只有run()方法而已，(extends)是继承Thread的方法，所有能使用它的所有方法。

 
定义一个线程类有哪两种基本方法是java的吗？ 1是通过继承线程java.lang.thread定义线程 1是通过实现java.lang.Runnable接口来定义线程。
 
实现多线程有几种方式，多线程同步怎么做，说说几多线程有两种实现方法，分别是继承Thread类与实现Runnable接口 同步的实现方面有两种，分别是synchronized,wait与notify人，不能陷在痛苦的泥潭里不能自拔。遇到不可能改变的现实，不管让人多么痛苦不堪，我们都要勇敢地面对，用微笑把痛苦埋葬，才能看到希望的阳光。
 
有三种： (1)继承Thread类，重写run函数 创建： class xx extends Thread{ public void run(){ Thread.sleep(1000)//线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源 }} 开启线程： 对象.start()//启动线程，run函数运行 (2)实现Runnab我徒手建了一座空城，里面空空如也，只为埋葬你带给我的温暖和感动。
 
java中创建线程的两种方式有什么区别
 
第一种方式：使用Runnable接口创建线程 第二种方式：直接继承Thread类创建对象 使用Runnable接口创建线程 1.可以将CPU，代码和数据分开，形成清晰的模型 2.线程体run()方法所在的类可以从其它类中继承一些有用的属性和方法 3.有利于保持程序的设有时候，你需要走出去，呼吸新鲜空气，提醒自己你是谁，你要成为谁。
 
java有几种实现线程的方式趁我还在对你说晚安，趁我还爱你，请好好珍惜这份情。
 
timertask算不算 为什么 各个实现线程的方式有什么不同。。。
 
java创建线程的方式有三种 第一种是继承Thread类 实现方法run() 不可以抛异常 无返回值 第二种是实现Runnable接口 实现方法run() 不可以抛异常 无返回值 第三种是实现Callable接口,接口中要覆盖的方法是 public call() 注意:此方法可以抛异常,而别不开心啦我给你个礼物诺喜欢吗我把我送给你。
 
java实现多线程的两种方法
 
Thread t1=new Thread(){ public void run(){ System.out.println("第一种方法"); } }; t1.start(); Thread t2=new Thread(new Runnable() { public void run() { System.out.println("第二种方法，可实现同类下各线程数据共享"); } }); t2.star我想再多看几眼星空，在这什么都善变的人世里，我想看一下永恒。
 
实现一个线程的执行有几种方法 ( )A.1种B在java5以前实现多线程有两种方法(继承Thread类和实现Runnable接口) 它们分别为： 使用new Thread()和new Thread(Runnable)形式 第一种直接调用thread的run方法，所以，往往使用Thread子类，即new SubThread()。
 
多线程有几种实现方法，都是什么？同步有几种实现java中多线程的实现方法有两种：1.直接继承thread类；2.实现runnable接口；同步的实现方法有五种：1.同步方法；2.同步代码块；3.使用特殊域变量(volatile)实现线程同步；4.使用重入锁实现线程同步；5.使用局部变量实现线程同步 。
 
java多线程，如何实现两个不同的方法
 
继承Thread类，写两个方法实现两个线程，一个方法实现每次i+1，另一个方class test1 implements Runnable{ @Override public void run() { // TODO Auto-generated method stub } public int add(int i){ return i+1; } public int del(int j){ return j-1; } } class test2 extends Thread{ @Override public void r有些人就是这样，信誓旦旦说爱你又悄无声息离开。别轻易就认为谁该是你世界，很多人最后关系就是没有关系。
 
Java多线程两种实现方式的比较实现多线程的两种方式，一种是继承Thread类，一种是实现Runnable接口，因为Runnable是一个接口，没有定义start()方法，只有run()方法而已，(extends)是继承Thread的方法，所有能使用它的所有方法。

一.使用synchronized关键字
 由于每个java对象都有一个内置锁，用synchronized修饰方法或者代码块时，内置锁会保护整个方法或代码块，要想执行这个方法或者代码块必须获得其内置锁，运行时会加上内置锁，当运行结束时，内置锁会打开。由于同步是一种高开销的工作，所以尽量减少同步的内容，只需同步代码块就可以。
 1.修饰方法
 
public class Test implements Runnable {
    static int i=0;
    public synchronized void test(){
    	System.out.println("当前线程为"+i);
    	i++;
    }
    public void run(){
    	test();
    }
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        Test t1=new Test();
        for(int i=0;i<10;i++){
        	Thread t11=new Thread(t1);
            t11.start();
        }
	}
}
 
结果如下：
 
 从上面结果看出，使用synchroniz修饰方法会在每个线程中按顺序依次执行。
 在使用该方法时要注意以下一点
 先看代码如下：
 
public class Test implements Runnable {
    static int i=0;
    public synchronized void test(){
    	System.out.println("当前线程为"+i);
    	i++;
    }
    public void run(){
    	test();
    }
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        for(int i=0;i<10;i++){
        	Test t1=new Test();
        	Thread t11=new Thread(t1);
            t11.start();
        }
	}
}
 
在看下结果：
 
 只是稍微修改了一处，结果就有很大不同，为什么会这样呢？我们发现上面两个代码，一个是在开始值创建一个Runnable的对象，一个是在for循环中每次都创建一个新的对象，就是因为synchronized是不能锁住不同对象的线程的，只能锁住同一个对象的线程，也就是说锁住的是方法所属的主体对象自身。
 
2.修饰代码块
 
public class Test implements Runnable {
    static int i=0;
    public void test(){
    	synchronized(this){System.out.println("当前线程为"+i);
    	i++;
    	}
    }
    public void run(){
    	test();
    }
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test t1=new Test();
        for(int i=0;i<10;i++){
        	Thread t11=new Thread(t1);
            t11.start();
        }
	}
}
 
运行结果和第一个程序一样的，不多解释了。
 
3.修饰静态方法
 
public static synchronized void anotherMethod() { 
    // do something 
} 
 
对于静态方法，锁住的不是这个类的对象，也不是也不是这个类自身，而是这个类所属的java.lang.Class类型的对象
 
二.wait与notify
 
wait()，使一个线程处于等待状态，并释放所持对象的锁，与sleep不同，sleep不会释放对象锁。
 notify()，唤醒一个处于阻塞状态的线程，进入就绪态，并加锁，只能唤醒一个线程，但不能确切知道唤醒哪一个，由JVM决定，不是按优先级。其实不是对对象锁的唤醒，是告诉调用wait方法的线程可以去竞争对象锁了。wait和notify必须在synchronized代码块中调用。
 notifyAll()，唤醒所有处于阻塞状态的线程，并不是给他们加锁，而是让他们处于竞争。
 为什么wait和notify要在synchronized代码块中使用
 调用wait()就是释放锁，释放锁的前提是必须要先获得锁，先获得锁才能释放锁，释放锁后进入等待队列。
 notify(),notifyAll()是将锁交给含有wait()方法的线程，让其继续执行下去，如果自身没有锁，怎么叫把锁交给其他线程呢；（本质是让处于阻塞队列的线程进入等待队列竞争锁）
 Synchronized应用举例：生产者消费者模型
 消费者线程需要等待直到生产者线程完成一次写入操作。生产者线程需要等待消费者线程完成一次读取操作。假设没有应用Synchronized关键字，当消费者线程执行wait操作的同时，生产线线程执行notify，生产者线程可能在等待队列中找不到消费者线程。导致消费者线程一直处于阻塞状态。那么这个模型就要失败了。所以必须要加Synchronized关键字。
 
生产者消费者代码实现：
 
package p2;

//使用wait与notify实现
public class ProducerConsumer {

    public static void main(String[] arg) {

        Resource resource = new Resource();
        // 生产者线程
        ProducerThread p1 = new ProducerThread(resource);
        ProducerThread p2 = new ProducerThread(resource);
        ProducerThread p3 = new ProducerThread(resource);
        // 消费者线程。测试时可以少开几个消费线程看看具体
        ConsumerThread c1 = new ConsumerThread(resource);
        ConsumerThread c2 = new ConsumerThread(resource);
        ConsumerThread c3 = new ConsumerThread(resource);

        p1.start();
        p2.start();
        p3.start();
        c1.start();
        c2.start();
        c3.start();

    }

}

// 编写资源类
class Resource {
//当前资源池数量
    private int currentSize = 0;
    //允许数量
    private int allowSize = 10;

    // 取走资源，如果当前资源大于0则可以移除（消费），移除之后唤醒生产线程。否则进入等待释放线程资源
    public synchronized void remove() {
        if (currentSize > 0) {
            currentSize--;
            System.out.println(Thread.currentThread().getName() + "消费一件资源，当前资源池有" + currentSize + "个");

            notifyAll();
        } else {

            // 没有资源 消费者进入等待状态
            try {
                System.out.println(Thread.currentThread().getName() + "当前资源过少，等待增加");
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

    }

    public synchronized void add() {
        // 如果当前数量小于限制数量则可以增加，增加后唤醒消费者消费,否则等待消费，释放锁
        if (currentSize < allowSize) {
            currentSize++;
            System.out.println(Thread.currentThread().getName() + "生产一件资源，当前资源池有" + currentSize + "个");
            notifyAll();

        } else {

            try {
                System.out.println(Thread.currentThread().getName() + "当前资源过多，等待消费");
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

    }

}
//消费线程
class ConsumerThread extends Thread {
    private Resource resource;

    ConsumerThread(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        while (true) {
            //避免生产消费太快测试的时候看不到打印，休眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //移除代表消费
            resource.remove();
        }

    }

}
//生产者线程
class ProducerThread extends Thread {
    private Resource resource;

    ProducerThread(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //生产
            resource.add();
        }

    }

}
 
三.volatile关键字
 前面提到的synchronized关键字锁住的是代码块，但是容易造成资源的浪费，是一种重量锁，而volatile是一种轻量锁，锁住的是变量。
 我们先来看下面的代码：
 
boolean value=false;
 --------------线程2------------- 
 public void change(){ value=true; }
  --------------线程1--------------
  public void output(){ if(value==true) System.out,println("输出成功"); }
 
上面的结果会输出什么呢？先执行线程2，再执行线程1，是否会输出成功呢？其实是不一定的，让我们来看下为什么：
 
 上面这张图表明，不同线程在执行时，数据都是从主内存中取得的，每个线程自身都有一个工作内存。线程读入和写入数据的过程如下：
 先从主内存中读取数据，放入工作内存，传递到线程中使用，在修改数据时，原路返回，经工作内存再写入到主内存中。
 这样就会有问题了，当两个线程1先把修改的数据经过工作内存写回到主内存的过程中，线程二读取主内存中的数据了，这样数据就出现了不一致性，我们把这种情况叫做线程之间不可见性。
 volatile关键字就是用来解决这种不可见问题的，它是怎么实现的呢？
 
使用volatile修饰的变量在被一个线程修改后，直接将数据写回到主内存，跳过了工作内存
 使用volatile修饰的变量，在被线程1修改后，线程二中的该变量就被视为无效
 线程2中数据无效了，在使用的时候就必须重新回主内存中读取该数据
 但是在使用volatile时需要注意一点，我们举个例子来说
 
public class Test implements Runnable {
	volatile int value=0;
	volatile int count=0;
	public void run(){
		for(int i=0;i<10000;i++){
			value++;
		}
		count++;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test test=new Test();
		for(int i=0;i<5;i++){
			Thread t=new Thread(test);
			t.start();
		}
		while(test.count!=5);
		System.out.println(test.value);
        
	}

}
 
看下结果：32130
 按理来说应该会输出50000，为什么会使那个结果呢？
 原因在于volatile不能满足原子性。
 原子性是指一个操作要么在执行时不被打断，要么就是不执行，原子操作只有最简单的赋值和读取。我们举例子讲解一下：
 
int a=1；
int b=a;
a++;
 
上面三个只有第一个是原子操作，第二个，先读取a的值，再赋值给b，两个原子操作叠加起来就不是原子操作，第三个，相当于a=a+1,先读取a的值，再加1，再赋值给a,也不是原子操作。
 注意：long和double的变量是64位的，不满足原子操作。
 了解了原子性我们想想为什么之前代码的结果不是500000。因为value的递增不是原子操作，volatile是无法保证原子性的。我们可以假设有这种情况，当value为100时线程1执行value自增的时候，比如说进行到了加1操作后被阻塞了，线程2接着进行value自增，线程2在主存中读取value值时会发现value还是100，那么线程1和线程2执行的结果都是101，相当于两次自增后value确只增加1，这就造成了实际值比500000小。
 
四.Lock
 前面的synchronized加锁，只有加锁和释放所=锁，在JDK5后出现了新的加锁方法，使用Lock，包含比synchronized更多的加锁功能。ReentrantLock类是实现了Lock接口的锁.ReentrantLock类的常用方法：
 
ReentrantLock() : 创建一个ReentrantLock实例 
lock() : 获得锁 
unlock() : 释放锁 
 
两者区别：
 
synchronized是java的关键字，是java的内置特性，是基于JVM层面的，而Lock是接口，是基于javaJDK层面的，通过这个接口可以实现同步访问。
 synchronized是不需要手动释放锁的，在代码执行完后，系统会让线程自动释放锁，但是Lock要手动解锁，如果不手动解锁，会出现死锁现象。
 
public class Test implements Runnable{
 Lock lock = new ReentrantLock();
  public void run(){
   lock.lock();
    try{
     String name=Thread.currentThread().getName(); 
     for(int i=0 ; i<5 ;i++){
     System.out.println("线程"+name+":"+i);
       } }
     catch(Exception e){
        }
      finally{ lock.unlock(); }
          } 
      public static void main(String[] args){ 
           Test test = new Test();
           Thread thread1 = new Thread(test,"1"); 
           thread1.start(); 
           Thread thread2 = new Thread(test,"2");
           thread2.start(); } }
 
结果如下:
 
 可以看出线程按顺序执行了，通常将要锁住的代码和方法放在try-catch中，在finally中释放锁，和synchronized一样，是对同一对象的两个线程。
 
五.ThreadLocal类
 使用ThreadLocal管理变量，每一个使用该变量的线程都获得该变量的副本，各个副本之间相互独立，每个线程都可以随意修改变量副本，而不会对其他线程造成影响。
 ThreadLocal类的常用方法
 
ThreadLocal() : 创建一个线程本地变量 
get() : 返回此线程局部变量的当前线程副本中的值 
initialValue() : 返回此线程局部变量的当前线程的"初始值" 
set(T value) : 将此线程局部变量的当前线程副本中的值设置为value
 
来看一下如何使用：
 
public class Test implements Runnable{ 
private static ThreadLocal<Integer> value = new ThreadLocal<Integer>(){
 protected Integer initialValue() { 
 return 0; 
   } 
 };
 public void run(){
  for(int i=0 ; i<5 ;i++)
  value.set(value.get()+1); 
  String name = Thread.currentThread().getName(); 
  System.out.println("线程"+name+":"+value.get());
   }
    public static void main(String[] args){
    Test test = new Test(); 
    Thread thread1 = new Thread(test,"1");
    thread1.start(); 
    Thread thread2 = new Thread(test,"2");
     thread2.start(); } }

 
结果如下：
 
 注：ThreadLocal与同步机制
 a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。
 b.前者采用以”空间换时间”的方法，后者采用以”时间换空间”的方式
 
 
 
摘选: https://tangyulu.com/233.htm
 

 
多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
 
同步的实现方面有两种，分别是synchronized,wait与notify
 
先看一下java线程运行时各个阶段的运行状态
 
java实现多线程有两种方法
 
1、继承Thread类
 
2、实现Runnable接口
 
这两种方法的共同点：
 
不论用哪种方法，都必须用Thread(如果是Thead子类就用它本身)产生线程，然后再调用start()方法。
 
两种方法的不同点：
 
1、继承Thread类有一个缺点就是单继承，而实现Runnable接口则弥补了它的缺点，可以实现多继承
 
2、继承Thread类必须如果产生Runnable实例对象，就必须产生多个Runnable实例对象，然后再用Thread产生多个线程；而实现Runnable接口，只需要建立一个实现这个类的实例，然后用这一个实例对象产生多个线程。即实现了资源的共享性
 
基于以上两点所以建议用第二种方法
 
下面用例子来做说明
 
程序1：
 
package com.dr.runnable1;
 
//一个类只要继承了Thread类，则此类就是多线程类
 
class MyThread extends Thread
 
{
 
private String name;
 
public MyThread(String name)
 
{
 
this.name=name;
 
}
 
//如果要使用多线程，则必须有一个方法的主体
 
public void run()
 
{
 
//打印输出
 
for(int i=0;i<10;i++)
 
{
 
System.out.println(this.name+"----->运行、、、、");
 
}
 
}
 
}
 
publicclassDemo1 {
 
public static void main(String args[])
 
{
 
//第一种方法
 
Runnable r1=new MyThread("线程A");
 
Runnable r2=new MyThread("线程B");
 
Runnable r3=new MyThread("线程C");
 
Thread t1=new Thread(r1);
 
Thread t2=new Thread(r2);
 
Thread t3=new Thread(r3);
 
t1.start();
 
t2.start();
 
t3.start();
 
//        mt1.run();//线程执行，使用start方法
 
//        mt2.run();
 
//        mt3.run();
 
//第二种方法
 
//       MyThread mt1=new MyThread("线程A");
 
//        MyThread mt2=new MyThread("线程B");
 
//        MyThread mt3=new MyThread("线程C");
 
//        mt1.start();
 
//        mt1.start();//线程只能启动一次
 
//        mt2.start();
 
//        mt3.start();
 
}
 
}
 
程序的运行结果是：
 
这是继承了Thread类，第一种方法产生多个Runnable实例对象，然后用Thread产生多个线程
 
第二种方法，因为这个类已经继承了Thread类，所以就可以直接利用它本身产生多个线程
 
程序2：
 
package com.dr.runnable1;
 
class MyThread1 implements Runnable
 
{
 
private  int ticket=10;
 
public void run()
 
{
 
for(int i=0;i<500;i++)
 
{
 
if(this.ticket>0)
 
{
 
System.out.println("卖票----->"+(this.ticket--));
 
}
 
}
 
}
 
}
 
publicclassDemo2 {
 
public static void main(String args[])
 
{
 
MyThread1 mt=new MyThread1();
 
Thread t1=new Thread(mt);
 
Thread t2=new Thread(mt);
 
Thread t3=new Thread(mt);
 
t1.start();
 
t2.start();
 
t3.start();
 
}
 
}
 
程序运行结果：
 
这个程序是实现Runnable了，产生一类的实例对象，然后用Thread产生多个线程。