Темы в Java

Ответ 1

Чтобы создать потоки, создайте новый класс, который расширяет класс Thread, и создайте экземпляр этого класса. Расширяющийся класс должен переопределить метод run() и метод start() вызова, чтобы начать выполнение потока.

Внутри run() вы определяете код, который представляет собой новый поток. Важно понимать, что run() может вызывать другие методы, использовать другие классы и объявлять переменные так же, как основной поток. Единственное различие заключается в том, что run() устанавливает точку входа для другого параллельного потока выполнения в вашей программе. Это закончится при возврате функции run().

public class MyThread extends Thread {

  String word;

  public MyThread(String rm){
    word = rm;
  }

  public void run(){

    try {

      for(;;){
        System.out.println(word);
        Thread.sleep(1000);
      }

    } catch(InterruptedException e) {

      System.out.println("sleep interrupted");      
    }
  }

  public static void main(String[] args) {

    Thread t1=new MyThread("First Thread");
    Thread t2=new MyThread("Second Thread");
    t1.start();
    t2.start();
  }
}

Экран вывода:

First Thread
Second Thread
First Thread
Second Thread
First Thread

и см. это:

http://www.javaworld.com/javaworld/jw-04-1996/jw-04-threads.html

а для Spring вы можете использовать пул потоков:

http://static.springsource.org/spring/docs/2.0.x/reference/scheduling.html

Ответ 2

Многопоточность - это Java-функция, которая позволяет одновременно выполнять две или более части программы для максимального использования CPU. Каждая часть такой программы называется потоком. Итак,

Нити - это легкие процессы в процессе.

Темы могут быть созданы с использованием двух механизмов:

• Расширение класса Thread
• Реализация Runnable Interface

Создание темы, расширяя класс Thread

Создаем класс, который расширяет класс java.lang.Thread. Этот класс переопределяет метод run(), доступный в классе Thread. Нить начинает свою жизнь внутри метода run(). Мы создаем объект нашего нового класса и вызываем метод start(), чтобы начать выполнение потока. start() вызывает метод run() объекта Thread.

class MultithreadingDemo extends Thread{
public void run()    {
    try {   // Displaying the thread that is running
        System.out.println ("Thread " + Thread.currentThread().getId() 
                                + " is running"); 
        }
        catch (Exception e){   // Throwing an exception
            System.out.println ("Exception is caught");
        }
    }
} 
public class Multithread{
    public static void main(String[] args)    {
        int n = 8; // Number of threads
        for (int i=0; i<8; i++)        {
            MultithreadingDemo object = new MultithreadingDemo();
            object.start();
        }
    }
}

Создание темы путем реализации Runnable Interface

Создаем новый класс, который реализует интерфейс java.lang.Runnable и переопределяет метод run(). Затем мы создаем объект Thread и вызываем метод start() для этого объекта.

class MultithreadingDemo implements Runnable{
public void run()    {
    try   {     // Displaying the thread that is running
        System.out.println ("Thread " +  Thread.currentThread().getId() +
                            " is running");

    }
    catch (Exception e)   {     // Throwing an exception
        System.out.println ("Exception is caught");
    }
    }
} 
class Multithread{
    public static void main(String[] args)    {
        int n = 8; // Number of threads
        for (int i=0; i<8; i++)        {
            Thread object = new Thread(new MultithreadingDemo());
            object.start();
        }
    }
}

Класс Thread vs Runnable Interface

• Если мы расширим класс Thread, наш класс не сможет расширить любой другой класс, потому что Java не поддерживает множественное наследование. Но, если мы реализуем интерфейс Runnable, наш класс может продолжать распространять другие базовые классы.

• Мы можем добиться базовых функциональных возможностей потока, расширив класс Thread, поскольку он предоставляет некоторые встроенные методы, такие как yield(), interrupt() и т.д., которые недоступны в интерфейсе Runnable.

Ответ 3

Я могу ответить на первые 3, так как я не слишком хорошо знаком с функциями Threading Spring или Flex.

• Поток - это объект, который имеет свои собственные регистры, стек и сегмент кода, которые могут выполняться параллельно с другими потоками процесса (процесс представляет собой набор потоков).

• Вы пишете многопоточный код для реагирования для взаимодействия с пользователем. Подумайте, насколько это было бы неприятно, если бы вам пришлось дождаться завершения загрузки вашего браузера, прежде чем вы сможете продолжить просмотр.

• Я привел пример в # 2. Другими примерами являются любые программы с графическим интерфейсом (GUI должен всегда реагировать на ввод пользователя при выполнении фоновых задач) или программное обеспечение типа сервера, такое как веб-сервер, на котором вам может потребоваться 1000 запросов в минуту. Было бы лучше иметь отдельный поток для каждого из этих ответов.

Ответ 4

Что касается Spring, да, вы можете определенно создать свои собственные потоки. Но лучше использовать поддержку пула потоков, описанную в Глава 25 руководства по Spring Framework.

Тем не менее, при наличии запросов на создание потоков в веб-службе на основе Spring (или любой другой веб-службе) возникают проблемы с управлением ресурсами, которые вы, возможно, захотите избежать...

Ответ 5

Одним из ключевых понятий для очистки является то, что поток - это объект планирования ОС, который просто имеет класс Java, который представляет его (как, скажем, Окно в подсистеме пользовательского интерфейса). Нити сами по себе не являются типом класса.

Ответ 6

Flex не может напрямую взаимодействовать с потоками Java, должно быть что-то вроде обмена сообщениями, используете ли вы JMS или что-то еще, Flex через BlazeDS, GraniteDS или LCDS может связываться с JMS. Не стоит забывать и о том, что в настоящий момент Flash/Flex сам по себе является однопоточным, но очень асинхронным... некоторые сказали бы, что TOO асинхронно... поэтому любое использование потоков Java для ускорения работы может не иметь как большой эффект, на который вы могли бы надеяться.

Ответ 7

Посмотрите оракул tutorial

• Что такое поток?

Потоки иногда называют легкими процессами. Темы существуют в процессе - каждый процесс имеет хотя бы один. Темы разделяют ресурсы процесса, включая память и открытые файлы. Это обеспечивает эффективную, но потенциально проблематичную связь.

2. Почему мы используем threading?

   • Многопоточное исполнение является важной особенностью платформы Java. Нитки независимы друг от друга.

   • Вы можете распараллелить свои вычисления, разбившись на несколько подвычислительных вычислений.

   • Вы можете эффективно использовать ядра процессора вашего сервера.

   например.

   ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
               .availableProcessors());
   

   если вы следуете принципу совместного доступа (который не всегда возможен) между вашими потоками, многопоточное приложение обеспечивает высокую пропускную способность.

3. Пример в реальном времени по потокам.

   Подумайте о приложении WhatsApp для чата.

   Сервер должен отправлять и получать сообщения чата среди тысяч пользователей. Однопоточное приложение является катастрофой для обработки этого варианта использования.

В чем разница между потоком и нормальным классом java. зачем нам потоки... Могу ли я выполнять бизнес-логику в потоках. Могу ли я вызвать другие методы класса в Threads.

Класс Thread может реализовать Runnable или расширить Thread. Посмотрите учебник оракула страница

Вы можете выполнить бизнес-логику в Threads.

Вы можете вызвать различные методы класса в Threads.

Ответ 8

Хорошо ответить на то, что является нитью в java простым словом, это программа/фрагмент кода, который работает одновременно с вашим обычным классом. Разница между нормальным классом и потоком заключается в том, что поток работает одновременно и работает параллельно с нормальным классом. В более простых терминах можно увидеть пример, где я в настоящее время находится в главной функции и требует функции для вычисления чего-то. поэтому, если эта функция не находится в потоке, тогда функция будет сначала оценена, а после этого я вернусь к основной функции, с другой стороны, если это поток, то функция будет вычисляться, а main будет также вычислять следующую инструкцию.

Теперь, как создается поток 1. расширить класс thread: расширить класс thread и написать start() его функцию вызвать его с помощью объекта текущего класса и записать функцию, а именно void run(), и в этой функции записать код, который необходимо выполнить одновременно.

Каждый объект класса, который расширяет поток, является настроенным thread.by по умолчанию, каждый поток неактивен и для активации или вызова этого потока просто пишет start(), это автоматически вызовет прогон, содержащий ваш код.

class MyThreads extends Thread
{
 int ch ;

 MyThreads(int p)
 {
  ch = p;
  start();//statement to activate thread and call run
 }  

 public void run()
 {
  if(ch == 1)
    functionx()
  else if(ch == 2)
    functiony();

 }

 void fx1()
 {
  //parallel running code here
 }

 void fx2()
 {
    //parallel running code here
 }

 public static void main(String args[])
 {

  MyThreads obj1 = new MyThreads(1);
  My3Threads obj2 = new MyThreads(2);

  //mains next instruction code here

 }
}

2. вы также можете реализовать интерфейс, а именно Runnable, но так как это интерфейс, который совместим с текущим классом, то запуск вызова вызовет функцию run(), которая написана в интерфейсе, но чтобы вызвать нашу функцию run() вызовите начало с объектом потока, подобным этому Thread t=new thread(this); t.start();

Теперь, почему мы идем на поток, это точно так же, как спросить, почему мы идем для многоядерного процессора, вы получаете то, что я говорю, многопоточность используется для одновременного выполнения задачи

Пример в реальном времени будет сервером любого сервера, рассмотрим сервер Gmail. Так что если почтовый сервер g не был написан с использованием многопоточности, то я не смог войти в систему, не выйдя из системы, что означает, что во всем мире только один человек может войти в систему, когда вы видите, насколько это непрактично.