本文目录
- java多线程有几种实现方法
- Java多线程编程的好处是什么
- 如何使用Java编写多线程程序(1)
- java多线程编程代码如下，输出结果如下:
- JAVA多线程程序设计，有追加100分
- java 多线程
- 什么是多线程编程
- JAVA多线程编程的几种表示方法
java多线程有几种实现方法
继承Thread类来实现多线程:
当我们自定义的类继承Thread类后，该类就为一个线程类,该类为一个独立的执行单元，线程代码必须编写在run()方法中,run方法是由Thread类定义，我们自己写的线程类必须重写run方法。
run方法中定义的代码为线程代码，但run方法不能直接调用，如果直接调用并没有开启新的线程而是将run方法交给调用的线程执行
要开启新的线程需要调用Thread类的start()方法，该方法自动开启一个新的线程并自动执行run方法中的内容
请点击输入图片描述
结果：
请点击输入图片描述
*java多线程的启动顺序不一定是线程执行的顺序，各个线程之间是抢占CPU资源执行的，所有有可能出现与启动顺序不一致的情况。
CPU的调用策略：
如何使用CPU资源是由操作系统来决定的，但操作系统只能决定CPU的使用策略不能控制实际获得CPU执行权的程序。
线程执行有两种方式：
1.抢占式：
目前PC机中使用最多的一种方式，线程抢占CPU的执行权，当一个线程抢到CPU的资源后并不是一直执行到此线程执行结束，而是执行一个时间片后让出CPU资源，此时同其他线程再次抢占CPU资源获得执行权。
2.轮循式;
每个线程执行固定的时间片后让出CPU资源，以此循环执行每个线程执行相同的时间片后让出CPU资源交给下一个线程执行。
Java多线程编程的好处是什么
多线程变成好处：
资源利用率更好
2.程序设计在某些情况下更简单
3.程序响应更快
详细请见：http://ifeve.com/benefits/
如何使用Java编写多线程程序(1)
一、简介1、什么是线程要说线程，就必须先说说进程，进程就是程序的运行时的一个实例。线程呢可以看作单独地占有CPU时间来执行相应的代码的。对早期的计算机（如DOS）而言，线程既是进程，进程既是进程，因为她是单线程的。当然一个程序可以是多线程的，多线程的各个线程看上去像是并行地独自完成各自的工作，就像一台一台计算机上运行着多个处理机一样。在多处理机计算机上实现多线程时，它们确实可以并行工作，而且采用适当的分时策略可以大大提高程序运行的效率。但是二者还是有较大的不同的，线程是共享地址空间的，也就是说多线程可以同时读取相同的地址空间，并且利用这个空间进行交换数据。 2、为什么要使用线程为什么要使用多线程呢？学过《计算机体系结构》的人都知道。将顺序执行程序和采用多线程并行执行程序相比，效率是可以大大地提高的。比如，有五个线程thread1, thread2, thread3, thread4, thread5，所耗的CPU时间分别为4，5，1，2，7。（假设CPU轮换周期为4个CPU时间，而且线程之间是彼此独立的）顺序执行需要花费1Array个CPU时间，而并行需要的时间肯定少于1Array个CPU时间，至于具体多少时间要看那些线程是可以同时执行的。这是在非常小规模的情况下，要是面对大规模的进程之间的交互的话，效率可以表现得更高。 3、java中是如何实现多线程的与其他语言不一样的是，线程的观念在java是语言中是重要的，根深蒂固的，因为在java语言中的线程系统是java语言自建的， java中有专门的支持多线程的API库，所以你可以以最快的速度写一个支持线程的程序。在使用java创建线程的时候，你可以生成一个Thread类或者他的子类对象，并给这个对象发送start()消息（程序可以向任何一个派生自 Runnable 接口的类对象发送 start() 消息的），这样一来程序会一直执行，直到run返回为止，此时该线程就死掉了。在java语言中，线程有如下特点：§ 在一个程序中而言，主线程的执行位置就是main。而其他线程执行的位置，程序员是可以自定义的。值得注意的是对Applet也是一样。§ 每个线程执行其代码的方式都是一次顺序执行的。§ 一个线程执行其代码是与其他线程独立开来的。如果诸线程之间又相互协作的话，就必须采用一定的交互机制。§ 前面已经说过，线程是共享地址空间的，如果控制不当，这里很有可能出现死锁。 各线程之间是相互独立的，那么本地变量对一个线程而言就是完全独立，私有的。所以呢，线程执行时，每个线程都有各自的本地变量拷贝。对象变量(instance variable)在线程之间是可以共享的，这也就是为什么在java中共享数据对象是如此的好用，但是java线程不能够武断地访问对象变量：他们是需要访问数据对象的权限的。二、准备知识 在分析这个例子之前，然我们先看看关于线程的几个概念，上锁，信号量，和java所提供的API。 上锁对于大多数的程序而言，他们都需要线程之间相互的通讯来完成整个线程的生命周期，二实现线程之间同步的最简单的办法就是上锁。为了防止相互关联的两个线程之间错误地访问共享资源，线程需要在访问资源的时候上锁和解锁，对于锁而言，有读锁，写锁和读写锁等不同的同步策略。在java中，所有的对象都有锁；线程只需要使用synchronized关键字就可以获得锁。在任一时刻对于给定的类的实例，方法或同步的代码块只能被一个线程执行。这是因为代码在执行之前要求获得对象的锁。 信号量通常情况下，多个线程所访问为数不多的资源，那怎么控制呢？一个比较非常经典而起非常简单的办法就是采用信号量机制。信号量机制的含义就是定义一个信号量，也就是说能够提供的连接数；当有一个线程占用了一个连接时，信号量就减一；当一个线程是放了连接时，信号量就加一。
java多线程编程代码如下，输出结果如下:
首先，你同步的是具体的某个Test实例， 对于那个实例来说，实际上只有一个线程访问了那个代码块，但是sum和other却是多个线程同时去进行访问，实际上这是不安全的，如果你想实现每次都输出10000的效果，那么正确的应该是在Test.class上加锁，而不是获取Test实例的锁，修改后的代码如下：
public class Test extends Thread { public static int sum = 10000; public static int other = 0; public void getMoney() { synchronized (Test.class) { System.out.println(Thread.currentThread().getName() + “ 开始执行“); sum = sum - 100; System.out.println(“sum-100“); other = other + 100; System.out.println(“other+100“); System.out.println(sum + other); System.out.println(Thread.currentThread().getName() + “ 执行完成“); } } public void run() { getMoney(); } public static void main(String agrs) { Thread t = new Thread; for (int i = 0; i 《= 9; i++) { t[i] = new Test(); t[i].start(); } }}
// 上面代码能得到你的结果
JAVA多线程程序设计，有追加100分
package com;import java.awt.Color;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.util.Random;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JPanel;public class ColorThread{public static void main(String args) { Myframe mf =new Myframe();//实例化对象 Thread t=new Thread(mf);//加入线程 t.start();//启动线程 }}class Myframe extends JFrame implements Runnable,ActionListener{ private static final long serialVersionUID = 1L; Random rand = new Random(System.currentTimeMillis());//随机数.用当前系统时间做基数 JPanel panel = new JPanel();//变色的面板 final JButton button = new JButton(“点击停止或启动“);//按钮 int action=0;//变色或停止变色 判断标示 public Myframe() { super(“1/10秒变色1次“); button.setBounds(10, 10, 200, 30); //设置按钮坐标 button.addActionListener(this); //设置按钮监听 panel.setBounds(10, 50, 100, 100); //面板坐标 panel.setBackground(Color.BLUE); //面板初始颜色 this.setBounds(100, 100, 300, 300); //frame 初始大小坐标 this.add(panel); //将面板加入frame this.setLayout(null); //设置frame布局为null this.add(button); //将按钮加入frame this.setDefaultCloseOperation(3); //设置关闭frame就退出程序 this.setVisible(true); //设置frame显示为可见 } /** * 实现Runnable线程接口 */ public void run() { while (true)//设置死循环 { try { if(action==0)//判断操作为0时改变面板背景颜色 { panel.setBackground(getcolor()); //变色 } Thread.sleep(100);//10之一秒 的休眠 } catch (InterruptedException e) { e.printStackTrace(); } } } private Color getcolor() //获得颜色 { return new Color(getNum(), getNum(), getNum()); } private int getNum() //获得小于255的随机数字 { return rand.nextInt(255); } public void actionPerformed(ActionEvent e)//监听事件 { if(action==0) //点击后判断.修改值. { action =1; }else { action =0; } }}//有注释了
java 多线程
所要执行的指令，也包括了执行指令所需的系统资源，不同进程所占用的系统资源相对独立。所以进程是重量级的任务，它们之间的通信和转换都需要操作系统付出较大的开销。 线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。所以线程是轻量级的任务，它们之间的通信和转换只需要较小的系统开销。 Java支持多线程编程，因此用Java编写的应用程序可以同时执行多个任务。Java的多线程机制使用起来非常方便，用户只需关注程序细节的实现，而不用担心后台的多任务系统。 Java语言里，线程表现为线程类。Thread线程类封装了所有需要的线程操作控制。在设计程序时，必须很清晰地区分开线程对象和运行线程，可以将线程对象看作是运行线程的控制面板。在线程对象里有很多方法来控制一个线程是否运行，睡眠，挂起或停止。线程类是控制线程行为的唯一的手段。一旦一个Java程序启动后，就已经有一个线程在运行。可通过调用Thread.currentThread方法来查看当前运行的是哪一个线程。 class ThreadTest{ public static void main(String args){ Thread t = Thread.currentThread(); t.setName(“单线程“); //对线程取名为“单线程“ t.setPriority(8); //设置线程优先级为8，最高为10，最低为1，默认为5 System.out.println(“The running thread: “ + t); // 显示线程信息 try{ for(int i=0;i《3;i++){ System.out.println(“Sleep time “ + i); Thread.sleep(100); // 睡眠100毫秒 } }catch(InterruptedException e){// 捕获异常 System.out.println(“thread has wrong“); } }}多线程的实现方法继承Thread类可通过继承Thread类并重写其中的run()方法来定义线程体以实现线程的具体行为，然后创建该子类的对象以创建线程。在继承Thread类的子类ThreadSubclassName中重写run()方法来定义线程体的一般格式为: public class ThreadSubclassName extends Thread{ public ThreadSubclassName(){ ..... // 编写子类的构造方法，可缺省 }public void run(){ ..... // 编写自己的线程代码 }}用定义的线程子类ThreadSubclassName创建线程对象的一般格式为: ThreadSubclassName ThreadObject = new ThreadSubclassName();然后，就可启动该线程对象表示的线程： ThreadObject.start(); //启动线程 应用继承类Thread的方法实现多线程的程序。本程序创建了三个单独的线程，它们分别打印自己的“Hello World!”。 class ThreadDemo extends Thread{ private String whoami; private int delay; public ThreadDemo(String s,int d){ whoami=s; delay=d; } public void run(){try{ sleep(delay); }catch(InterruptedException e) System.out.println(“Hello World!“ + whoami + “ “ + delay); } } public class MultiThread{ public static void main(String args){ ThreadDemo t1,t2,t3; t1 = new ThreadDemo(“Thread1“, (int)(Math.random()*2000));t2 = new ThreadDemo(“Thread2“, (int)(Math.random()*2000)); t3 = new ThreadDemo(“Thread3“, (int)(Math.random()*2000)); t1.start(); t2.start(); t3.start(); }}实现Runnable接口编写多线程程序的另一种的方法是实现Runnable接口。在一个类中实现Runnable接口(以后称实现Runnable接口的类为Runnable类),并在该类中定义run()方法，然后用带有Runnable参数的Thread类构造方法创建线程。创建线程对象可用下面的两个步骤来完成:(1)生成Runnable类ClassName的对象 ClassName RunnableObject = new ClassName();(2)用带有Runnable参数的Thread类构造方法创建线程对象。新创建的线程的指针将指向Runnable类的实例。用该Runnable类的实例为线程提供 run()方法---线程体。 Thread ThreadObject = new Thread(RunnableObject);然后，就可启动线程对象ThreadObject表示的线程：ThreadObject.start();在Thread类中带有Runnable接口的构造方法有: public Thread(Runnable target); public Thread(Runnable target, String name); public Thread(String name);public Thread(ThreadGroup group，Runnable target); public Thread(ThreadGroup group，Runnable target， String name); 其中，参数Runnable target表示该线程执行时运行target的run()方法，String name以指定名字构造线程，ThreadGroup group表示创建线程组。用Runnable接口实现的多线程。class TwoThread implements Runnable{ TwoThread(){ Thread t1 = Thread.currentThread(); t1.setName(“第一主线程“); System.out.println(“正在运行的线程: “ + t1); Thread t2 = new Thread(this,“第二线程“); System.out.println(“创建第二线程“); t2.start(); try{ System.out.println(“第一线程休眠“); Thread.sleep(3000); }catch(InterruptedException e){System.out.println(“第一线程有错“); } System.out.println(“第一线程退出“); } public void run(){ try{ for(int i = 0;i 《 5;i++){ System.out.println(“第二线程的休眠时间：” + i); Thread.sleep(1000); } }catch(InterruptedException e){ System.out.println(“线程有错“); }System.out.println(“第二线程退出“); } public static void main(String args){ new TwoThread(); }}程序运行结果如下：正在运行的线程: Thread[第一主线程,5,main创建第二线程第一线程休眠第二线程的休眠时间：0第二线程的休眠时间：1第二线程的休眠时间：2第一线程退出第二线程的休眠时间：3第二线程的休眠时间：4第二线程退出另外,虚机团上产品团购,超级便宜
什么是多线程编程
多线程编程技术是Java语言的重要特点。多线程编程的含义是将程序任务分成几个并行的子任务。特别是在网络编程中，你会发现很多功能是可以并发执行的。比如网络传输速度较慢、用户输入速度较慢，你可以用两个独立的线程去完成这两个功能，而不影响正常的显示或其它功能。 多线程是与单线程比较而言的，普通的Windows采用单线程程序结构，其工作原理是：主程序有一个消息循环，不断从消息队列中读入消息来决定下一步所要干的事情，一般是针对一个函数，只有等这个函数执行完之后，主程序才能接收另外的消息来执行。比如子函数功能是在读一个网络数据，或读一个文件，只有等读完这个数据或文件才能接收下一个消息。在执行这个子函数过程中你什么也不能干。但往往读网络数据和等待用户输入有很多时间处于等待状态，多线程利用这个特点将任务分成多个并发任务后，就可以解决这个问题。 Java中的线程类 1.扩展java.lang.Thread类，用它覆盖Thread类的run方法。 2.生成实现java.lang.Runnable接口的类并将其它的实例与java.lang.Thread实例相关联。 Thread类是负责向其它类提供线程支持的最主要的类，要使用一个类具有线程功能，在Java中只要简单地从Thread类派生一个子类就可以了扩展Thread类，如printThread.java。 Thread类最重要的方法是run方法。run方法是新线程执行的方法，因此生成java.lang.Thread的子类时，必须有相应的run方法。//PrintThread.javapublic class PrintThread extends Thread//继承Tread类private int count=0//定义一个count变量用于统计打印的次数并共享变量public static void mainString args//main方法开始PrintThread p=new PrintThread//创建一个线程实例p.start//执行线程for{;;}//主线程main方法执行一个循环，for执行一个死循环count++System.out.printcount+″：Main\n″//主线程中打印count+“main”变量的值，并换行public void run//线程类必须有的run（）方法for{;;}count++System.out.printcount+″：Thread\n″ 上面这段程序便是继承java.lang.Tread并覆盖run的方法。用Java虚拟机启动程序时，这个程序会先生成一个线程并调用程序主类的main方法。这个程序中的main方法生成新线程，连接打印“Thread”。在启动线程之后，主线程继续打印“Main”。 编译并执行这个程序，然后立即按“Ctrl+C”键中断程序，你会看到上面所述的两个线程不断打印出：XXX：main…..XXX：Thread….XXX代表的是数字，也就是上面count的值。在笔者的机器上，不同时刻这两个线程打印的次数不一样，先打印20个main（也就是先执行20次主线程）再打印出50次Thread，然后再打印main…… 提示：为了便于查看该程序的执行结果，你可以将执行结果导入一个文本文件，然后打开这个文件查看各线程执行的情况。如运行：javac PrintThread.javaJava PrintThread1.txt 第一个命令javacPrintThread.java是编译java程序，第二个是执行该程序并将结果导入1.txt文件。当然你可以直接执行命令：java
JAVA多线程编程的几种表示方法
创建线程有两种方法：继承Thread类和实现Runnable接口。方法一：继承 Thread 类，覆盖方法 run()，我们在创建的 Thread 类的子类中重写 run() ,加入线程所要执行的代码即可。下面是一个例子：public class MyThread extends Thread {int count= 1, number;public MyThread(int num) {number = num;System.out.println(“创建线程 “ + number);}public void run() {while(true) {System.out.println(“线程 “ + number + “:计数 “ + count);if(++count== 6) return;}}public static void main(String args) {for(int i = 0; i 《 5; i++) new MyThread(i+1).start();}}方法二：实现 Runnable 接口 Runnable 接口只有一个方法 run()，我们声明自己的类实现 Runnable 接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是 Runnable 接口并没有任何对线程的支持，我们还必须创建 Thread 类的实例，这一点通过 Thread 类的构造函数public Thread(Runnable target);来实现。下面是一个例子：public class MyThread implements Runnable {int count= 1, number;public MyThread(int num) {number = num;System.out.println(“创建线程 “ + number);}public void run() {while(true) {System.out.println(“线程 “ + number + “:计数 “ + count);if(++count== 6) return;} }public static void main(String args) {for(int i = 0; i 《 5; i++) new Thread(new MyThread(i+1)).start();}} 两种方法各有千秋，可以灵活运用。