java多线程编程

Ⅰ 《java多线程编程核心技术》和《java并发编程的艺术》两本书的异同

区别很大：

《java多线程编程核心技术》：
这本书让你入个门，整体上了介绍一些并发编程的基本API、常见场景和一些坑，推荐先看这本书，比较简单，适合新手，但是原理不够深入
和《java并发编程的艺术》
这本书从底层和实现原理开始讲起，深入java内存模型和处理器的知识讲解并发编程的实现原理，适合有一定基础的人看

Ⅱ Java多线程编程的好处是什么

多线程变成好处：

1. 资源利用率更好

2. 

   详细请见：http://ifeve.com/benefits/

   Ⅲ 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();
   }
   }
   两种方法各有千秋，可以灵活运用。

   Ⅳ 什么是Java多线程编程

   一、 什么是多线程：

   我们现在所使用操作系统都是多任务操作系统(早期使用的DOS操作系统为单任务操作系统)，多任务操作指在同一时刻可以同时做多件事(可以同时执行多个程序)。

   • 多进程:每个程序都是一个进程，在操作系统中可以同时执行多个程序,多进程的目的是为了有效的使用CPU资源，每开一个进程系统要为该进程分配相关的系统资源(内存资源)

   • 多线程:线程是进程内部比进程更小的执行单元(执行流|程序片段),每个线程完成一个任务,每个进程内部包含了多个线程每个线程做自己的事情，在进程中的所有线程共享该进程的资源；

   • 主线程:在进程中至少存在一个主线程，其他子线程都由主线程开启,主线程不一定在其他线程结束后结束，有可能在其他线程结束前结束。Java中的主线程是main线程,是Java的main函数;

   二、 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点：
   1. wake() 这个方法也要同步啊，加关键字synchronized ；
   2. 第一次调用st（）方法后，available应该保持不变，这样才能保证线程b也打印..start，所以加个if判断一下就ok啦。
   
   public class ABC {
   
   boolean available=false;
   String name;
   int count=0;
   public ABC(String name){
   this.name=name;
   }
   public synchronized void st(){
   System.out.println("... start.");
   count++;
   if(count>1){
   available=true;
   }
   try{
   wait();
   }catch(Exception e){}
   System.out.println("... end.");
   }
   public synchronized void end(){
   System.out.println("... end.");
   }
   public synchronized void wake() {
   notifyAll();
   }
   
   public static void main(String[] args) {
   // TODO Auto-generated method stub
   ABC x=new ABC("haha");
   TestThread a=new TestThread(x);
   TestThread b=new TestThread(x);
   C c=new C(x);
   (new Thread(a)).start();
   (new Thread(b)).start();
   (new Thread(c)).start();
   }
   }
   class TestThread implements Runnable{
   ABC abc;
   public TestThread(ABC abc){
   this.abc=abc;
   }
   public void run(){
   if(!abc.available){
   abc.st();
   }
   else abc.end();
   
   }
   }
   class C implements Runnable{
   ABC abc;
   public C(ABC abc){
   this.abc=abc;
   }
   public void run(){
   try{
   Thread.sleep(1000);
   // System.out.println("sjlfsj jfsdl j"); //验证是否执行到这里
   }catch(InterruptedException e){};
   abc.wake();
   }
   }

   Ⅵ JAVA多线程编程求教

   代码就不给了，给你个思路，用一个线程刷新标签的颜色，再设置一个变量判断是否执行（比如boolean run=true），点击按钮后变量设置run为false，再点一下又变回true，这样就可以了，思路有了应该好做了，楼主加油

   Ⅶ java多线程编程小题

   我有个java多线程的问题，向你请教，题目如下：编写一个多线程程序实现如下第一次调用st（）方法后，available应该保持不变，这样才能保证线程b也打印.v

   Ⅷ 求JAVA多线程编程代码

   测试过了，没问题。基本思路，实例化一个桥类，谁得到桥的可用标志谁过桥。
   我第一个看到这个100分的，说实话，知道你是个学生要代码而已，线程类好久没练手了，练习一下而已，否则真不会给你写代码。因为我读书的时候也发过类似的求助，知道什么感受。不懂的时候真的没办法，所以告诉你思路。
   package cn.thread;
   
   public class Through_out_bridge {
   
   public static void main(String[] args) {
   Bridge b = Bridge.getInstance();//实例化桥
   //实例化左端9个人，此时所有人都不能过桥，桥的可以状态标志为不可以用
   for (int i = 1; i <= 9; i++) {
   Thread t = new Thread(new Person(false, i, b));
   t.start();
   }
   //实例化右端12个人，此时所有人都不能过桥，桥的可以状态标志为不可以用
   for( int i=1 ;i<=12;i++)
   {
   Thread t = new Thread(new Person(true,i,b));
   t.start();
   }
   //桥的可用状态给左端第10个人，可以自定义给谁
   b.state = true;
   Thread t = new Thread(new Person(false, 10, b));
   }
   
   }
   
   class Person implements Runnable {
   
   public Bridge bridge;//桥
   private String hand;//在桥哪一端
   int No;//序号
   
   public Person(boolean side, int i, Bridge bridge) {
   
   this.No = i;
   this.bridge = bridge;
   if(bridge.state)
   {
   System.out.println(i+"已经过桥。");
   }
   if (side) {
   this.hand = new String("右");
   } else {
   this.hand = new String("左");
   }
   }
   
   //过桥方法
   public synchronized void through() throws InterruptedException {
   
   if (bridge.state) {
   System.out.println(hand+"边第"+No + "在过桥");
   bridge.open( No);
   } else {
   bridge.lock(No);
   
   }
   }
   
   public void run() {
   try {
   Thread.sleep(1000);
   // System.out.println(No+hand+" 边已经过桥!");
   through();
   } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   }
   }
   }
   
   class Bridge {
   //可用状态判断true：可用
   public boolean state = false;
   //自行实例化
   public static Bridge getInstance() {
   return new Bridge();
   }
   
   public synchronized void open(int i) throws InterruptedException {
   if (state) {
   Thread.sleep(1000);
   this.state=true;
   notify();
   }
   }
   
   public synchronized void lock(int i) throws InterruptedException {
   if (!state) {
   this.state=false;
   System.out.println(i + " 在等待.");
   wait();
   }
   }
   }

   Ⅸ java多线程网络编程

   将所有处理动作写成Thread
   假如:ServerSenderThread是服务器的发送线程
   ServerAccepterThread是服务器的接受线程
   ClientSenderThread是客户端发送线程
   ClientAccepterThread是客户端接受线程
   并在 ServerAccepterThread 中写一个方法，当接受到"exit"字符串，就结束线程

   Ⅹ java多线程编程问题

   线程同步问题，好解决