beratur

Connection Vs.

Jana kelas tugas

Struktur kelas tugas

Agih tugas
Pengagihan tertunda

Penyelarasan tertunda
Sambungan rantai kerja & beratur

Maksimum bilangan percubaan
percubaan berasaskan masa
Tamat masa

Had kekerapan

Pengendalian ralat

Penutupan giliran

Tamat Tempoh Tugas & Tamat Masa
Tamat Tempoh Tugas
Masa Pemproses

Masa Tidur Proses Beratur
Pengawasan ll Penyelia

mission events

.
- Struktur tugas
  - Tugas pengagihan /nilai tamat masa
  - Sekatan akses
- - Penutupan Baris Gilir
  - Jalankan Pemproses Giliran
- - Acara tugasan
- Pengenalan
  - {tip} Laravel kini menawarkan Horizon, papan pemuka dan sistem konfigurasi yang cantik untuk baris gilir Redis anda. Lihat dokumentasi Horizon penuh untuk mendapatkan maklumat lanjut.
  - Fail konfigurasi baris gilir disimpan dalam fail config/queue.php. Konfigurasi untuk setiap pemacu baris gilir boleh didapati dalam fail ini, termasuk pangkalan data, Beanstalkd, Amazon SQS
  - dan pemacu segerak (penggunaan tempatan). Ia juga mengandungi pemacu baris gilir null untuk tugasan yang membatalkan baris gilir.
- Connection Vs. Queue
  Sebelum mula menggunakan Laravel queue, adalah penting untuk memahami perbezaan antara "connection" dan "queue". Dalam fail konfigurasi config/queue.php anda, terdapat pilihan konfigurasi connections. Pilihan ini mentakrifkan sambungan unik kepada perkhidmatan bahagian belakang seperti Amazon SQS, Beanstalk atau Redis. Sama ada cara, mungkin terdapat berbilang "baris gilir" untuk sambungan tertentu dan "baris gilir" boleh dianggap sebagai tindanan yang berbeza atau sejumlah besar tugas beratur. config/queue.php 配置文件里，有一个 connections 配置选项。这个选项给 Amazon SQS，Beanstalk，或者 Redis 这样的后端服务定义了一个特有的连接。不管是哪一种，一个给定的连接可能会有多个「队列」，而「队列」可以被认为是不同的栈或者大量的队列任务。
  要注意的是，queue 配置文件中每个连接的配置示例中都包含一个 queue 属性。这是默认队列任务被发给指定连接的时候会被分发到这个队列中。换句话说，如果你分发任务的时候没有显式定义队列，那么它就会被放到连接配置中 queue 属性所定义的队列中：
```
// 这个任务将被分发到默认队列...
Job::dispatch();
// 这个任务将被发送到「emails」队列...
Job::dispatch()->onQueue('emails');
```
  有些应用可能不需要把任务发到不同的队列，而只发到一个简单的队列中就行了。但是把任务推到不同的队列仍然是非常有用的，因为 Laravel 队列处理器允许你定义队列的优先级，所以你能给不同的队列划分不同的优先级或者区分不同任务的不同处理方式了。比如说，如果你把任务推到 high 队列中，你就能让队列处理器优先处理这些任务了：
```
php artisan queue:work --queue=high,default
```
  驱动的必要设置
  Database
  为了使用 database 队列驱动，你需要一张数据表来存储任务。运行 queue:table Artisan 命令来创建这张表的迁移文件。当迁移文件创建好后，你就可以使用 migrate 命令来进行迁移：
```
php artisan queue:table
php artisan migrate
```
  Redis
  为了使用 redis 队列驱动，你需要在 config/database.php 配置文件中配置 Redis 的数据库连接。
  Redis 集群
  如果你的 Redis 队列驱动使用了 Redis 集群，你的队列名必须包含一个 key hash tag 。这是为了确保所有的 Redis 键对于一个队列都被放在同一哈希中。
```
'redis' => [ 
   'driver' => 'redis',    
   'connection' => 'default',    
   'queue' => '{default}',    
   'retry_after' => 90,
],
```
  阻塞
  当使用 Redis 队列时，你可以用 block_for 配置项来具体说明驱动应该在将任务重新放入 Redis 数据库以及处理器轮询之前阻塞多久。
  基于你的队列加载来调整这个值比把新任务放入 Redis 数据库轮询要更有效率的多。例如，你可以将这个值设置为 5
  Perlu diambil perhatian bahawa contoh konfigurasi bagi setiap sambungan dalam fail konfigurasi queue mengandungi atribut queue. Ini ialah tugas baris gilir lalai yang akan diedarkan kepada baris gilir ini apabila ia dihantar ke sambungan yang ditentukan. Dalam erti kata lain, jika anda tidak mentakrifkan baris gilir secara eksplisit semasa mengagihkan tugas, ia akan diletakkan dalam baris gilir yang ditakrifkan oleh atribut queue dalam konfigurasi sambungan:
```
'redis' => [
    'driver' => 'redis',    
    'connection' => 'default',    
    'queue' => 'default',    
    'retry_after' => 90,    
    'block_for' => 5,
  ],
```
  Sesetengah aplikasi mungkin tidak perlu Tugasan dihantar ke baris gilir yang berbeza, tetapi hanya kepada baris gilir yang mudah. Tetapi menolak tugas ke baris gilir yang berbeza masih sangat berguna, kerana pengendali baris gilir Laravel membolehkan anda menentukan keutamaan baris gilir, supaya anda boleh menetapkan keutamaan yang berbeza kepada baris gilir yang berbeza atau membezakan kaedah pemprosesan yang berbeza untuk tugas yang berbeza. Contohnya, jika anda menolak tugasan ke baris gilir tinggi, anda boleh membenarkan pemproses baris gilir mengutamakan tugasan ini: 🎜
```
php artisan make:job ProcessPodcast
```
  🎜 🎜
  🎜🎜Tetapan yang diperlukan untuk pemandu🎜
  🎜
  Pangkalan Data
  🎜Untuk menggunakan < kod>pangkalan data Pemacu baris gilir, anda memerlukan jadual data untuk menyimpan tugas. Jalankan perintah queue:table Artisan untuk mencipta fail migrasi untuk jadual ini. Selepas fail migrasi dibuat, anda boleh menggunakan perintah migrate untuk berhijrah: 🎜
```
<?php
    namespace App\Jobs;
    use App\Podcast;
    use App\AudioProcessor;
    use Illuminate\Bus\Queueable;
    use Illuminate\Queue\SerializesModels;
    use Illuminate\Queue\InteractsWithQueue;
    use Illuminate\Contracts\Queue\ShouldQueue;
    use Illuminate\Foundation\Bus\Dispatchable;
    class ProcessPodcast implements ShouldQueue{ 
       use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;    
       protected $podcast;    
     /**
     * 创建一个新的任务实例。
     *
     * @param  Podcast  $podcast
     * @return void
     */   
     public function __construct(Podcast $podcast)  
       {      
         $this->podcast = $podcast;  
         }   
     /**
     * 运行任务。
     *
     * @param  AudioProcessor  $processor
     * @return void
     */   
     public function handle(AudioProcessor $processor)   
      {       
        // Process uploaded podcast...   
       }
    }
```
  🎜
  Redis
  🎜 Untuk menggunakan pemacu baris gilir redis, anda perlu mengkonfigurasi sambungan pangkalan data Redis dalam fail konfigurasi config/database.php. 🎜🎜Kluster Redis🎜🎜Jika pemandu baris gilir Redis anda menggunakan Kluster Redis, nama baris gilir anda mesti mengandungi teg cincang utama . Ini adalah untuk memastikan semua kekunci Redis untuk baris gilir diletakkan dalam cincang yang sama. 🎜
  use App\Jobs\ProcessPodcast; $this->app->bindMethod(ProcessPodcast::class.'@handle', function ($job, $app) {     return $job->handle($app->make(AudioProcessor::class)); });
  🎜Menyekat🎜🎜Apabila menggunakan baris gilir Redis, anda boleh menggunakan item konfigurasi block_for untuk menentukan bahawa pemandu harus memasukkan semula tugas ke dalam pangkalan data dan tinjauan pendapat Redis pemproses Berapa lama ia telah disekat sebelum ini. 🎜🎜Melaraskan nilai ini berdasarkan beban baris gilir anda adalah lebih cekap daripada meletakkan tugas baharu ke dalam pangkalan data Redis dan mengundinya. Sebagai contoh, anda boleh menetapkan nilai ini kepada 5 untuk menunjukkan bahawa pemandu harus menyekat selama 5 saat sementara menunggu tugasan tersedia. 🎜
  <?php     namespace App\Http\Controllers;     use App\Jobs\ProcessPodcast;     use Illuminate\Http\Request;     use App\Http\Controllers\Controller;     class PodcastController extends Controller{         /**      * 存储一个新的播客节目。      *      * @param  Request  $request      * @return Response      */        public function store(Request $request)         {               // 创建播客...                 ProcessPodcast::dispatch($podcast);          }   }
  🎜🎜
  Pakej sambungan kebergantungan pemacu baris gilir lain
  Sebelum menggunakan perkhidmatan baris gilir dalam senarai, anda mesti memasang pakej sambungan kebergantungan berikut:
  Amazon SQS: aws/aws-sdk-php ~3.0 < /li>aws/aws-sdk-php ~3.0
  Beanstalkd: pda/pheanstalk ~4.0
  Redis: predis/predis ~1.0
  创建任务
  生成任务类
  在你的应用程序中，队列的任务类都默认放在 app/Jobs 目录下。如果这个目录不存在，那当你运行 make:job Artisan 命令时目录就会被自动创建。你可以用以下的 Artisan 命令来生成一个新的队列任务：
  <?php     namespace App\Http\Controllers;     use App\Jobs\ProcessPodcast;     use Illuminate\Http\Request;     use App\Http\Controllers\Controller;class PodcastController extends Controller{         /**      * 存储一个新的播客节目。      *      * @param  Request  $request      * @return Response      */        public function store(Request $request)         {              // 创建播客...               ProcessPodcast::dispatch($podcast)                       ->delay(now()->addMinutes(10));            }     }
  生成的类实现了 IlluminateContractsQueueShouldQueue 接口，这意味着这个任务将会被推送到队列中，而不是同步执行。
  任务类结构
  任务类的结构很简单，一般来说只会包含一个让队列用来调用此任务的 handle 方法。我们来看一个示例的任务类。这个示例里，假设我们管理着一个播客发布服务，在发布之前需要处理上传播客文件：
  <?php     namespace App\Http\Controllers;     use Illuminate\Http\Request;     use App\Jobs\ProcessPodcast;     use App\Http\Controllers\Controller;     class PodcastController extends Controller{        /**      * Store a new podcast.      *      * @param  Request  $request      * @return Response      */       public function store(Request $request)        {              // Create podcast...               ProcessPodcast::dispatchNow($podcast);         }     }
  注意，在这个例子中，我们在任务类的构造器中直接传递了一个 Eloquent 模型。因为我们在任务类里引用了 SerializesModels 这个 trait，使得 Eloquent 模型在处理任务时可以被优雅地序列化和反序列化。如果你的队列任务类在构造器中接收了一个 Eloquent 模型，那么只有可识别出该模型的属性会被序列化到队列里。当任务被实际运行时，队列系统便会自动从数据库中重新取回完整的模型。这整个过程对你的应用程序来说是完全透明的，这样可以避免在序列化完整的 Eloquent 模式实例时所带来的一些问题。
  在队列处理任务时，会调用 handle 方法，而这里我们也可以通过 handle 方法的参数类型提示，让 Laravel 的服务容器自动注入依赖对象。
  如果你想完全控制容器如何将依赖对象注入至 handle 方法，可以使用容器的 bindMethod 方法。bindMethod 方法接受一个任务和容器的回调。虽然可以直接在回调中可以调用 handle 方法，但建议应该从 service provider 调用为佳：
  ProcessPodcast::withChain([    new OptimizePodcast,        new ReleasePodcast ])->dispatch();
  {note} 像图片内容这种二进制数据，在放入队列任务之前必须使用 base64_encodeBeanstalkd: pda/pheanstalk ~4.0
Mencipta pekerjaan
🎜 < div name="17bfa2" data-unique="17bfa2">🎜
Jana kelas tugas
🎜Dalam aplikasi anda, kelas tugas baris gilir diletakkan dalam app/Jobs direktori. Jika direktori ini tidak wujud, ia akan dibuat secara automatik apabila anda menjalankan perintah make:job Artisan. Anda boleh menggunakan perintah Artisan berikut untuk menjana tugas baris gilir baharu: 🎜
```
ProcessPodcast::withChain([
    new OptimizePodcast,    
    new ReleasePodcast
 ])->dispatch()->allOnConnection('redis')->allOnQueue('podcasts');
```
🎜Kelas yang dijana melaksanakan antara muka IlluminateContractsQueueShouldQueue, yang bermaksud bahawa tugas itu akan ditolak ke baris gilir dan bukannya dilaksanakan secara serentak . 🎜🎜
🎜🎜
🎜
Struktur kelas tugas
🎜Struktur kelas tugas adalah sangat mudah , secara amnya Mengatakan ia hanya akan mengandungi kaedah handle yang digunakan oleh baris gilir untuk memanggil tugas ini. Mari lihat kelas tugas contoh. Dalam contoh ini, anggap bahawa kami menguruskan perkhidmatan penerbitan podcast dan perlu memproses fail podcast yang dimuat naik sebelum menerbitkan: 🎜
```
<?php
    namespace App\Http\Controllers;
    use App\Jobs\ProcessPodcast;
    use Illuminate\Http\Request;
    use App\Http\Controllers\Controller;
    class PodcastController extends Controller{   
     /**
     * 存储一个新的播客节目。
     *
     * @param  Request  $request
     * @return Response
     */    
   public function store(Request $request)    
   {      
     // 创建播客...      
       ProcessPodcast::dispatch($podcast)->onQueue('processing');   
    }
  }
```
🎜 Ambil perhatian bahawa dalam contoh ini, kami menghantar model Eloquent terus dalam pembina kelas tugas. Oleh kerana kami merujuk sifat SerializesModels dalam kelas tugas, model Eloquent boleh disiri dan dinyahsiri dengan anggun apabila memproses tugasan. Jika kelas tugas baris gilir anda menerima model Eloquent dalam pembina, hanya sifat yang mengenali model itu akan disirikan ke baris gilir. Apabila tugas itu benar-benar dijalankan, sistem beratur secara automatik mendapatkan semula model lengkap daripada pangkalan data. Keseluruhan proses ini benar-benar telus untuk aplikasi anda, yang mengelakkan beberapa masalah yang datang dengan bersiri contoh penuh corak Eloquent. 🎜🎜Apabila baris gilir memproses tugas, kaedah handle akan dipanggil, dan di sini kita juga boleh menggunakan pembayang jenis parameter kaedah handle untuk membenarkan bekas perkhidmatan Laravel secara automatik menyuntik objek bergantung. 🎜🎜Jika anda ingin mempunyai kawalan penuh ke atas cara bekas menyuntik objek bergantung ke dalam kaedah handle, anda boleh menggunakan kaedah bindMethod bekas. Kaedah bindMethod menerima panggilan balik tugas dan bekas. Walaupun kaedah handle boleh dipanggil terus dalam panggilan balik, adalah disyorkan untuk memanggilnya daripada pembekal perkhidmatan: 🎜
```
<?php
    namespace App\Http\Controllers;
    use App\Jobs\ProcessPodcast;
    use Illuminate\Http\Request;
    use App\Http\Controllers\Controller;
    class PodcastController extends Controller{   
     /**
     * 存储一个新播客节目。
     *
     * @param  Request  $request
     * @return Response
     */   
    public function store(Request $request)   
     {       
      // 创建播客...       
      ProcessPodcast::dispatch($podcast)->onConnection('sqs');   
      }
   }
```
🎜{note} Data binari seperti kandungan imej harus diletakkan dalam tugas baris gilir Anda mesti menggunakan kaedah base64_encode untuk menukarnya sebelum ini. Jika tidak, apabila tugas ini diletakkan pada baris gilir, ia mungkin tidak bersiri dengan betul kepada JSON. 🎜🎜🎜🎜🎜🎜🎜🎜
Agihkan tugas
Setelah anda selesai menulis kelas tugasan anda, anda boleh menggunakan kaedah dispatch sendiri untuk mengedarkannya. Parameter yang dihantar kepada kaedah dispatch akan dihantar kepada pembina tugasan: dispatch 方法分发它。传递给 dispatch 方法的参数将会被传递给任务的构造函数：
ProcessPodcast::dispatch($podcast) ->onConnection('sqs') ->onQueue('processing');
延迟分发
如果你想延迟你的队列任务的执行，你可以在分发任务的时候使用 delay 方法。例如，让我们详细说明一个十分钟之后才会执行的任务：
```
php artisan queue:work --tries=3
```
{note} Amazon SQS 队列服务最大延迟 15 分钟的时间。
同步调度
如果您想立即（同步）执行队列任务，可以使用 dispatchNow 方法。使用此方法时，队列任务将不会排队，并立即在当前进程中运行：
```
<?phpnamespace App\Jobs;class ProcessPodcast implements ShouldQueue{    
     /**
     * 任务可以尝试的最大次数。
     *
     * @var int
     */    
    public $tries = 5;}
```
工作链
工作链允许你具体定义一个按序列执行队列任务的列表。一旦序列中的任务失败了，剩余的工作将不会执行。要运行一个工作链，你可以对可分发的任务使用 withChain 方法：
```
/**
 * 定义任务超时时间
 *
 * @return \DateTime
 */
 public function retryUntil(){
     return now()->addSeconds(5);
  }
```
{note} 使用 $this->delete() 方法删除队列任务不会阻止工作链任务执行。只有当工作链中的任务执行失败时，工作链才会停止执行。
工作链连接 & 队列
如果你想定义用于工作链的默认连接和队列，你可以使用 allOnConnection 和 allOnQueue 方法。这些方法指定了所需队列的连接和队列 —— 除非队列任务被明确指定给了不同的连接 / 队列：
```
php artisan queue:work --timeout=30
```
自定义连接 & 队列
分发任务到指定队列
通过将任务分发到不同队列，你可以将你的队列任务「分类」，甚至指定给不同队列分配的任务数量。记住，这不是推送任务到你定义的队列配置文件的不同的连接里，而是一个单一的连接。要指定队列，在分发任务时使用 onQueue 方法：
```
<?php
    namespace App\Jobs;class ProcessPodcast implements ShouldQueue{  
     /**
     * 任务可以执行的最大秒数 (超时时间)。
     *
     * @var int
     */   
    public $timeout = 120;}
```
分发任务到指定连接
如果你在多队列连接中工作，你可以指定将任务分发到哪个连接。要指定连接，在分发任务时使用 onConnection 方法：
```
Redis::throttle('key')->allow(10)->every(60)->then(function () {
    // 任务逻辑...
  },
 function () { 
   // 无法获得锁...    
  return $this->release(10);
});
```
当然，你可以链式调用 onConnection 和 onQueue
```
Redis::funnel('key')->limit(1)->then(function () {
    // 任务逻辑...},
    function () {  
      // 无法获得锁...   
     return $this->release(10);
 });
```
Pengagihan Tertunda
Jika anda ingin menangguhkan pelaksanaan tugas baris gilir anda, anda boleh menggunakan kaedah kelewatan semasa mengagihkan tugas. Sebagai contoh, mari kita perincikan tugas yang tidak akan dilaksanakan selama sepuluh minit:
$podcast = App\Podcast::find(1); dispatch(function () use ($podcast) { $podcast->publish(); });
{nota} Perkhidmatan baris gilir Amazon SQS mempunyai kependaman maksimum 15 minit. 🎜
🎜🎜🎜
🎜
penghantaran segerak
🎜Jika anda mahu segera ( synchronous ) untuk melaksanakan tugas baris gilir, anda boleh menggunakan kaedah dispatchNow. Apabila menggunakan kaedah ini, tugas beratur tidak akan beratur dan dijalankan serta-merta dalam proses semasa: 🎜
php artisan queue:work
🎜
🎜🎜
🎜
Rantai Kerja
🎜Rantai kerja membolehkan anda mentakrifkan secara khusus senarai tugas baris gilir yang dilaksanakan mengikut turutan. Sebaik sahaja tugasan dalam urutan gagal, kerja yang selebihnya tidak akan dilaksanakan. Untuk menjalankan rantaian kerja, anda boleh menggunakan kaedah withChain pada tugasan boleh agih: 🎜
php artisan queue:work redis
🎜{note} Gunakan kaedah $this->delete() Memadamkan tugas baris gilir tidak menghalang tugas rantaian kerja daripada dilaksanakan. Rantaian kerja akan berhenti melaksanakan hanya apabila tugasan dalam rantaian kerja gagal dilaksanakan. 🎜
🎜
Sambungan & Baris Gilir Rantai Kerja
🎜Jika anda ingin menentukan sambungan lalai dan baris gilir untuk rantai kerja, anda boleh Gunakan < kaedah kod>allOnConnection dan allOnQueue. Kaedah ini menentukan sambungan dan baris gilir baris gilir yang diingini - melainkan tugas baris gilir secara eksplisit diberikan kepada sambungan/baris gilir yang berbeza: 🎜
php artisan queue:work redis --queue=emails
🎜🎜🎜🎜
Sambungan & baris gilir tersuai
🎜
Agihkan tugas kepada baris gilir yang ditentukan < /h4>🎜Dengan mengagihkan tugas kepada baris gilir yang berbeza, anda boleh "mengkategorikan" tugas baris gilir anda dan juga menentukan bilangan tugas yang diberikan kepada baris gilir yang berbeza. Ingat, ini bukan menolak tugasan ke sambungan berbeza dalam fail konfigurasi baris gilir yang anda tentukan, tetapi kepada satu sambungan. Untuk menentukan baris gilir, gunakan kaedah onQueue semasa mengagihkan tugas: 🎜
php artisan queue:work --once
🎜
Agihkan tugas kepada sambungan yang ditentukan
🎜 Jika anda sedang mengusahakan sambungan berbilang baris gilir, anda boleh menentukan sambungan untuk mengagihkan tugas itu. Untuk menentukan sambungan, gunakan kaedah onConnection semasa menghantar tugasan: 🎜
php artisan queue:work --stop-when-empty
🎜Sudah tentu, anda boleh merantai kaedah onConnection dan onQueue untuk menentukan sambungan dan baris gilir. 🎜
dispatch((new Job)->onQueue('high'));
🎜🎜🎜🎜🎜🎜
Nyatakan bilangan maksimum percubaan tugasan/nilai tamat masa
Bilangan maksimum percubaan
Menentukan bilangan maksimum percubaan dalam tugasan boleh ditentukan melalui pilihan --try pada perintah Artisan : --tries 选项指定：
php artisan queue:work --queue=high,low
你可能想通过任务类自身对最大任务尝试次数进行一个更颗粒化的处理。如果最大尝试次数是在任务类中定义的，它将优先于命令行中的值提供：
php artisan queue:restart
基于时间的尝试
作为另外一个选择来定义任务在失败前会尝试多少次，你可以定义一个任务超时时间。这样的话，在给定的时间范围内，任务可以无限次尝试。要定义一个任务的超时时间，在你的任务类中新增一个 retryUntil 方法：
php artisan queue:work --timeout=60
{tip} 你也可以在你的队列事件监听器中使用 retryUntil 方法。
超时
{note} timeout 特性对于 PHP 7.1+ 和 pcntl PHP 扩展进行了优化.
同样的，任务执行最大秒数的数值可以通过 Artisan 命令行的 --timeout
php artisan queue:work --sleep=3
Anda mungkin mahu Pemprosesan yang lebih terperinci bagi bilangan maksimum percubaan tugasan dilakukan melalui kelas tugas itu sendiri. Jika bilangan maksimum percubaan ditakrifkan dalam kelas tugas, ia akan diberikan sebagai keutamaan kepada nilai pada baris arahan:
sudo apt-get install supervisor
Percubaan berasaskan masa
Sebagai alternatif untuk menentukan berapa kali tugasan akan dicuba sebelum gagal, anda boleh menentukan tamat masa tugas. Dengan cara ini, tugasan itu boleh dicuba bilangan kali tanpa had dalam jangka masa tertentu. Untuk menentukan tamat masa tugasan, tambahkan kaedah retryUntil pada kelas tugasan anda: 🎜
[program:laravel-worker] process_name=%(program_name)s_%(process_num)02d command=php /home/forge/app.com/artisan queue:work sqs --sleep=3 --tries=3 autostart=true autorestart=true user=forge numprocs=8 redirect_stderr=true stdout_logfile=/home/forge/app.com/worker.log
🎜{tip} Anda juga boleh menggunakan kaedah retryUntil anda. 🎜
🎜🎜Timeout🎜
🎜{note} ciri timeout untuk PHP 7.1+ dan pcntl< /code> Sambungan PHP telah dioptimumkan 🎜
🎜Begitu juga, nilai bilangan maksimum saat untuk pelaksanaan tugas boleh ditentukan melalui pilihan --timeout pada baris arahan Artisan. 🎜sudo supervisorctl reread sudo supervisorctl update sudo supervisorctl start laravel-worker:* 🎜Walau bagaimanapun, anda juga mungkin mahu menentukan tamat masa dalam kelas tugas itu sendiri. Jika dinyatakan dalam kelas tugas, keutamaan akan lebih tinggi daripada baris arahan: 🎜php artisan queue:failed-table php artisan migrate 🎜🎜🎜🎜🎜🎜Penghadan Kekerapan {nota} Ciri ini memerlukan aplikasi anda boleh menggunakan pelayan Redis Jika aplikasi anda menggunakan Redis, anda boleh mengehadkan tugas giliran anda mengikut masa atau serentak. Ciri ini berguna apabila tugas baris gilir anda digunakan melalui API yang juga mempunyai kadar terhad. Sebagai contoh, menggunakan kaedah throttle, anda boleh mengehadkan tugasan jenis tertentu untuk hanya melaksanakan 10 kali setiap 60 saat. Jika kunci tidak diperoleh, anda harus meletakkan semula tugasan itu ke dalam baris gilir supaya ia boleh dicuba semula kemudian. throttle 方法，你可以限制一个给定类型的任务每 60 秒只执行 10 次。如果没有获得锁，一般情况下你应该将任务放回队列以使其可以被稍后重试。 php artisan queue:work redis --tries=3 {tip} 在上述的例子里，key 可以是任何你想要限制频率的任务类型的唯一识别字符串。例如，使用构件基于任务类名的 key，或它操作的 Eloquent 模型的 ID。 {note} 将受限制的作业释放回队列，仍然会增加工作的总数 attempts。或者，你可以指定一个任务可以同时执行的最大数量。在如下情况时这会很有用处：当一个队列中的任务正在修改资源时，一次只能被一个任务修改。例如，使用 funnel 方法，你可以限制一个给定类型的任务一次只能执行一个处理器： <?php     namespace App\Jobs;     use Exception;use App\Podcast;     use App\AudioProcessor;     use Illuminate\Bus\Queueable;     use Illuminate\Queue\SerializesModels;     use Illuminate\Queue\InteractsWithQueue;     use Illuminate\Contracts\Queue\ShouldQueue;     class ProcessPodcast implements ShouldQueue{        use InteractsWithQueue, Queueable, SerializesModels;            protected $podcast;         /**      * 创建任务实例      *      * @param  Podcast  $podcast      * @return void      */         public function __construct(Podcast $podcast)          {                $this->podcast = $podcast;           }        /**      * 执行任务      *      * @param  AudioProcessor  $processor      * @return void      */        public function handle(AudioProcessor $processor)         {                 // 上传播客……             }       /**      * 任务失败的处理过程      *      * @param  Exception  $exception      * @return void      */         public function failed(Exception $exception)         {                // 给用户发送任务失败的通知，等等……             }       } {tip} 当使用频率限制时，任务执行成功的尝试的次数可能会难以确定。所以，将频率限制与时间限制组合是很有作用的。错误处理如果在任务执行的时候出现异常，任务会被自动释放到队列中以再次尝试。任务将会一直被释放直到达到应用允许的最大重试次数。最大重试的数值由 queue:work Artisan 命令的 --tries <?php     namespace App\Providers;     use Illuminate\Support\Facades\Queue;     use Illuminate\Queue\Events\JobFailed;     use Illuminate\Support\ServiceProvider;     class AppServiceProvider extends ServiceProvider{         /**      * 启动任意服务。      *      * @return void      */         public function boot()         {              Queue::failing(function (JobFailed $event) {                   // $event->connectionName                          // $event->job                          // $event->exception                    });        }         /**      * 注册服务提供者。      *      * @return void      */         public function register()    {            //               }     } {tip} Dalam contoh di atas, kunci boleh menjadi sebarang rentetan pengecam unik untuk jenis tugasan yang anda mahu hadkan kekerapannya. Sebagai contoh, gunakan kunci widget berdasarkan nama kelas tugas atau ID model Eloquent yang dikendalikannya.
{note} Mengeluarkan kerja terhad kembali ke baris gilir masih meningkatkan jumlah bilangan kerja cubaan.
Sebagai alternatif, anda boleh menentukan bilangan maksimum tugasan yang boleh dilaksanakan serentak. Ini boleh berguna apabila tugasan dalam baris gilir mengubah suai sumber yang hanya boleh diubah suai oleh satu tugas pada satu masa. Contohnya, menggunakan kaedah corong, anda boleh mengehadkan tugasan jenis tertentu kepada satu pemproses sahaja pada satu masa:
php artisan queue:failed
{tip} Apabila menggunakan pengehadan kekerapan, bilangan pelaksanaan tugas yang berjaya percubaan Ia boleh menjadi sukar untuk ditentukan. Jadi, adalah berguna untuk menggabungkan had kekerapan dengan had masa
.
Ralat pengendalian
Jika pengecualian berlaku semasa pelaksanaan tugas, tugas akan dikeluarkan secara automatik Beratur untuk mencuba lagi. Tugasan akan dilepaskan sehingga bilangan percubaan semula maksimum yang dibenarkan oleh aplikasi dicapai. Nilai cuba semula maksimum ditakrifkan oleh pilihan --try bagi perintah queue:work Artisan, atau dalam kelas tugas. Maklumat lanjut tentang pengendali giliran pelaksanaan boleh didapati
di bawah 🎜 . 🎜🎜🎜🎜🎜🎜🎜🎜Penutupan Giliran🎜🎜Anda juga boleh menghubungi penutupan terus dan bukannya menjadualkan kelas tugasan ke baris gilir. Ini berguna untuk tugasan cepat dan mudah yang perlu dilakukan: 🎜
php artisan queue:retry 5
🎜 Apabila penutupan dihantar ke baris gilir, kandungan kod penutupan ditandatangani secara kriptografi supaya ia tidak boleh diubah suai dalam transit. 🎜🎜🎜🎜🎜🎜🎜
Run Queue Handler
Laravel termasuk pengendali baris gilir untuk melaksanakan tugas yang ditolak ke baris gilir. Anda boleh menggunakan perintah queue:work Artisan untuk menjalankan pemproses. Ambil perhatian bahawa sebaik sahaja perintah queue:work memulakan pelaksanaan, ia akan terus berjalan sehingga ia dihentikan secara manual atau terminal ditutup. queue:work Artisan 命令运行处理器。注意一旦 queue:work 命令开始执行，它会一直运行直到它被手动停止或终端被关闭。
php artisan queue:retry all
{tip} 要使 queue:work 进程一直在后台运行，你应该使用进程管理器比如 Supervisor 来确保队列处理器不会停止运行
记住，队列处理器是一个常驻的进程并且在内存中保存着已经启动的应用状态。因此，它们并不会在启动后注意到你代码的更改。所以，在你的重新部署过程中，请记得重启你的队列处理器.
指定连接 & 队列
你也可以具体说明队列处理器应该使用哪个队列连接。传递给 work 的连接名应该与你的 config/queue.php 配置文件中定义的连接之一相符。
php artisan queue:forget 5
你甚至可以自定义你的队列处理器使其只执行连接中指定的队列。例如，如果你的所有邮件都由 redis 连接的 emails 队列处理，你可以使用如下的命令启动一个仅执行此队列的处理器：
php artisan queue:flush
执行单一任务
--once 选项用于使队列处理器只处理队列中的单一任务。
/** * 如果模型缺失即删除任务。 * * @var bool */ public $deleteWhenMissingModels = true;
处理所有队列的任务然后退出
--stop-when-empty 选项可用于处理队列处理器处理所有作业然后优雅地退出。如果您希望在队列为空后关闭容器，则在 Docker 容器中运行 Laravel 队列时，此选项很有用：
<?php     namespace App\Providers;     use Illuminate\Support\Facades\Queue;     use Illuminate\Support\ServiceProvider;     use Illuminate\Queue\Events\JobProcessed;     use Illuminate\Queue\Events\JobProcessing;     class AppServiceProvider extends ServiceProvider{          /**      * 引导启动任意应用服务。      *      * @return void      */         public function boot()         {                Queue::before(function (JobProcessing $event) {                    // $event->connectionName                             // $event->job                             // $event->job->payload()                     });               Queue::after(function (JobProcessed $event) {                     // $event->connectionName                           // $event->job                           // $event->job->payload()                    });    }        /**      * 注册服务提供者。      *      * @return void      */        public function register()       {           //        }   }
资源注意事项
后台驻留的队列处理器不会在执行完每个任务后「重启」框架。因此，你应该在每个任务完成后释放任何占用过大的资源。例如，如果你正在用 GD 库执行图像处理，你应该在完成后使用 imagedestroy
Queue::looping(function () {    while (DB::transactionLevel() > 0) {           DB::rollBack();           }     });
{tip} Untuk memastikan proses queue:work berjalan di latar belakang, anda harus menggunakan pengurus proses seperti Supervisor
untuk pastikan baris gilir Pemproses tidak berhenti berjalan
Ingat, pemproses baris gilir ialah proses pemastautin dan memegang keadaan aplikasi yang dimulakan dalam ingatan. Oleh itu, mereka tidak akan melihat perubahan pada kod anda selepas permulaan. Jadi, semasa proses penempatan semula anda, sila ingat untuk mulakan semula pemproses baris gilir anda
.
Nyatakan sambungan & baris gilir
🎜Anda juga boleh menentukan sambungan baris gilir yang harus digunakan oleh pengendali baris gilir. Nama sambungan yang dihantar ke work harus sepadan dengan salah satu sambungan yang ditakrifkan dalam fail konfigurasi config/queue.php anda. 🎜rrreee🎜Anda juga boleh menyesuaikan pengendali baris gilir anda untuk hanya melaksanakan baris gilir yang dinyatakan dalam sambungan. Contohnya, jika semua e-mel anda diproses oleh baris gilir e-mel yang disambungkan ke redis, anda boleh memulakan pemproses yang hanya melaksanakan baris gilir ini menggunakan arahan berikut: 🎜rrreee
🎜
Laksanakan satu tugasan
🎜--sekali pilihan digunakan untuk menjadikan pemproses baris gilir hanya memproses satu tugasan dalam barisan. 🎜rrreee
🎜
Proses semua tugasan beratur dan kemudian keluar
🎜--stop-bila-kosong pilihan boleh digunakan Pengendali baris gilir memproses semua kerja dan kemudian keluar dengan anggun. Pilihan ini berguna apabila menjalankan baris gilir Laravel dalam bekas Docker jika anda ingin menutup bekas itu selepas baris gilir kosong: 🎜rrreee
🎜
Nota Sumber
🎜Pemproses baris gilir penduduk latar belakang tidak akan "memulakan semula" rangka kerja selepas melaksanakan setiap tugas. Oleh itu, anda harus melepaskan sebarang sumber yang berlebihan selepas setiap tugas selesai. Contohnya, jika anda melakukan pemprosesan imej dengan pustaka GD, anda harus menggunakan imagedestroy untuk membebaskan memori apabila anda selesai. 🎜🎜🎜🎜🎜🎜🎜
Keutamaan Beratur
Kadangkala anda mungkin mahu mengutamakan pelaksanaan giliran. Contohnya, dalam config/queue.php anda boleh menetapkan keutamaan baris gilir queue yang disambungkan dengan redis daripada default adalah rendah. Walau bagaimanapun, kadangkala anda mungkin mahu menolak tugasan ke baris gilir tinggi seperti berikut: config/queue.php 中你可以将 redis 连接的 queue 队列的优先级从 default 设置为 low。然而，偶尔你也想像如下方式将一个任务推送到 high 队列：
rrreee
要运行一个处理器来确认 low 队列中的任务在全部的 high 队列任务完成后才继续执行，你可以传递一个逗号分隔的队列名列表作为 work 命令的参数。
rrreee
队列处理器 & 部署
因为队列处理器是常驻进程，他们在重启前不会应用你代码的更改。因此，部署使用队列处理器的应用最简单的方法是在部署进程中重启队列处理器。你可以平滑地重启所有队列处理器通过使用 queue:restart 方法：
rrreee
这个命令将会引导所有的队列处理器在完成当前任务后平滑「中止」，这样不会有丢失的任务。由于在执行 queue:restart 后队列处理器将会中止，所以你应该运行一个进程管理器例如 Supervisor 来自动重启队列处理器。
{tip} 队列使用缓存存储重启信号，所以你应该确定在使用这个功能之前配置好缓存驱动。
任务过期 & 超时
任务过期
在你的 config/queue.php 配置文件中，每个队列连接都定义了一个 retry_after 选项。这个选项指定了队列连接在重试一个任务前应该等它执行多久。例如，如果 retry_after 的值设置为 90 ，那么任务在执行了 90 秒后将会被放回队列而不是删除它。一般情况下，你应该将 retry_after 的值设置为你认为你的任务可能会执行需要最长时间的值。
{note} 只有在 Amazon SQS 中不存在 retry_afterrrreee
Untuk menjalankan pemproses untuk mengesahkan bahawa tugas dalam baris gilir rendah adalah dalam semua >high Tugasan baris gilir akan dilaksanakan hanya selepas ia selesai Anda boleh menghantar senarai nama baris gilir yang dipisahkan koma sebagai argumen kepada perintah work.
rrreee
🎜🎜Queue Processor & Deployment🎜🎜Oleh kerana Queue Processor adalah pemastautin proses, mereka tidak akan menggunakan perubahan pada kod anda sehingga ia dimulakan semula. Oleh itu, cara paling mudah untuk menggunakan aplikasi yang menggunakan pemproses baris gilir adalah untuk memulakan semula pemproses baris gilir semasa proses penggunaan. Anda boleh memulakan semula semua pemproses baris gilir dengan anggun dengan menggunakan kaedah queue:restart: 🎜rrreee🎜Arahan ini akan mengarahkan semua pemproses baris gilir untuk "membatalkan" dengan anggun selepas menyelesaikan tugas semasa, jadi tidak akan ada misi Hilang . Memandangkan pengendali baris gilir akan ditamatkan selepas melaksanakan queue:restart, anda harus menjalankan pengurus proses seperti Supervisor untuk memulakan semula pemproses baris gilir secara automatik. 🎜
🎜{tip} Baris gilir menggunakan cache untuk menyimpan isyarat mulakan semula, jadi anda harus memastikan untuk mengkonfigurasi pemacu cache sebelum menggunakan ciri ini. 🎜🎜🎜🎜
🎜🎜Tas tamat tempoh & tamat masa🎜
🎜
Tanggal Tempoh Tugas
🎜Dalam fail konfigurasi config/queue.php anda, setiap sambungan baris gilir mentakrifkan retry_after pilihan. Pilihan ini menentukan berapa lama sambungan baris gilir perlu menunggu tugasan sebelum mencubanya semula. Contohnya, jika nilai retry_after ditetapkan kepada 90 , maka tugasan akan dimasukkan semula ke dalam baris gilir selepas 90 saat pelaksanaan dan bukannya dipadamkan. Secara umum, anda harus menetapkan nilai retry_after kepada nilai yang anda fikir tugas anda mungkin mengambil masa paling lama untuk dilaksanakan. 🎜
🎜{note} Nilai retry_after tidak wujud hanya dalam Amazon SQS. SQS akan mencuba semula tugas berdasarkan nilai tamat masa yang boleh dilihat lalai yang dikonfigurasikan dalam konsol AWS. 🎜🎜🎜🎜
Tamat Masa Pemproses
baris gilir:kerja Perintah Artisan mengandungi pilihan --masa tamat. Pilihan --timeout menentukan berapa lama proses induk baris gilir Laravel menunggu sebelum membatalkan proses anak melaksanakan tugas. Kadangkala proses kanak-kanak mungkin "membeku" atas pelbagai sebab, seperti gagal membalas permintaan HTTP luaran. Pilihan --timeout akan mengalih keluar proses yang telah dibekukan lebih lama daripada masa yang ditentukan. queue:work Artisan 命令包含一个 --timeout 选项。 --timeout 选项指定了 Laravel 的队列主进程在中止一个执行任务的子进程之前需要等到多久。有时一个子进程可能会因为各种原因「冻结」，比如一个外部的 HTTP 请求失去响应。 --timeout 选项会移除那些超过指定时间被冻结的进程。
rrreee
retry_after 配置项和 --timeout 命令行配置并不同，但将它们同时使用可以确保任务不会丢失并且任务只会成功执行一次。
{note} --timeout 的值应该比你在 retry_after 中配置的值至少短几秒。这会确保处理器永远会在一个任务被重试之前中止。如果你的 --timeout 值比 retry_after 的值长的话，你的任务可能会被执行两次。
队列进程睡眠时间
当任务在队列中可用时，处理器将会一直无间隔地处理任务。然而， sleep 选项定义了如果没有新任务的时候处理器将会「睡眠」多长时间。在处理器睡眠时，它不会处理任何新任务 —— 任务将会在队列处理器再次启动后执行。
rrreee
Supervisor 配置
安装 Supervisor
Supervisor 是 Linux 操作系统下中的一个进程监控器，它可以在 queue:work 挂掉时自动重启之。在 Ubuntu 上安装 Supervisor，你可以使用如下命令：
rrreee
{小提醒} 如果觉得配置 Supervisor 难于登天，可以考虑使用 Laravel Forge，它将自动为你的 Laravel 项目安装和配置 Supervisor。
配置 Supervisor
Supervisor 的配置文件通常位于 /etc/supervisor/conf.d 目录下。在该目录中，你可以创建任意数量的配置文件，用来控制 supervisor 将如何监控你的进程。例如，创建一个 laravel-worker.conf 文件使之启动和监控一个 queue:work 进程：
rrreee
在这个例子中，numprocs 指令将指定 Supervisor 运行 8 个 queue:work 进程并对其进行监控，如果它们挂掉就自动重启它们。你应该更改 command 选项中的 queue：work sqsrrreee
Item konfigurasi retry_after dan konfigurasi baris arahan --timeout tidak berbeza, tetapi menggunakannya bersama-sama boleh memastikan bahawa tugas tidak akan hilang dan tugas itu akan hanya boleh dilaksanakan dengan jayanya sekali.
{note} Nilai --timeout hendaklah sekurang-kurangnya beberapa saat lebih pendek daripada nilai yang anda konfigurasikan dalam retry_after. Ini memastikan bahawa pemproses akan sentiasa dihentikan sebelum sesuatu tugas boleh dicuba semula. Jika nilai --timeout anda lebih panjang daripada nilai retry_after, tugas anda boleh dilaksanakan dua kali. 🎜
🎜🎜Masa tidur proses baris gilir🎜🎜Apabila tugasan tersedia dalam baris gilir, pemproses akan sentiasa memproses tugasan tanpa sebarang jeda. Walau bagaimanapun, pilihan tidur mentakrifkan berapa lama pemproses akan "tidur" jika tiada tugasan baharu. Semasa pemproses sedang tidur, ia tidak akan memproses sebarang tugas baharu - tugasan akan dilaksanakan apabila pemproses baris gilir dimulakan semula. 🎜rrreee🎜🎜
🎜
Konfigurasi penyelia
🎜🎜Install Supervisor🎜🎜Supervisor ialah pemantau proses di bawah sistem pengendalian Linux Ia boleh dimulakan semula secara automatik apabila queue:work hang. Untuk memasang Supervisor pada Ubuntu, anda boleh menggunakan arahan berikut: 🎜rrreee
🎜{Tips} Jika anda mendapati sukar untuk mengkonfigurasi Supervisor, anda boleh mempertimbangkan untuk menggunakan Laravel Forge, yang akan memasang dan mengkonfigurasi Penyelia secara automatik untuk projek Laravel anda. 🎜
🎜🎜Configuring Supervisor🎜🎜Fail konfigurasi Supervisor biasanya terletak dalam direktori /etc/supervisor/conf.d . Dalam direktori ini, anda boleh mencipta sebarang bilangan fail konfigurasi untuk mengawal cara penyelia akan memantau proses anda. Contohnya, buat fail laravel-worker.conf yang memulakan dan memantau proses queue:work: 🎜rrreee🎜Dalam contoh ini, numprocs Arahan tersebut akan menentukan Penyelia untuk menjalankan 8 proses queue:work dan memantaunya serta memulakan semula proses secara automatik jika ia digantung. Anda harus menukar bahagian queue:work sqs pada pilihan command untuk mewakili sambungan baris gilir yang anda inginkan. 🎜🎜🎜
Start Supervisor
Selepas fail konfigurasi dibuat, anda boleh menggunakan arahan berikut untuk mengemas kini konfigurasi Supervisor dan mulakan proses:
rrreee
Untuk maklumat lanjut tentang Supervisor, anda boleh menyemak Supervisor documentation.

Mengendalikan tugas yang gagal
Kadangkala tugasan anda yang beratur akan gagal dilaksanakan. Rehatkan fikiran anda, perkara yang baik hanya datang pada masanya. Laravel termasuk kaedah kemudahan untuk menentukan bilangan maksimum kali tugas harus dicuba. Jika kerja telah mencapai bilangan maksimum percubaan, ia dimasukkan ke dalam jadual pangkalan data failed_jobs. Untuk mencipta jadual migrasi pangkalan data failed_jobs, anda boleh menggunakan perintah queue:failed-table:
rrreeefailed_jobs 数据库表中。要创建 failed_jobs 数据库迁移表，你可以使用 queue:failed-table 命令：
rrreee
然后，当你运行 queue worker，你应该使用 queue：work 命令中的 --tries 开关指定应尝试运行任务的最大次数。如果没有为 --tries 选项指定值，则将死循环尝试运行任务：
rrreee
任务失败后清理
你可以直接在任务类中定义 failed 方法，允许你在任务失败时执行针对于该任务的清理工作。这是向用户发送警报或恢复任务执行的任何操作的绝佳位置。导致任务失败的 Exception 将被传递给 failed 方法：
rrreee
任务失败事件
如果你想在任务失败时注册一个可调用的事件，你可以使用 Queue::failing 方法。该事件是通过 email 或 Slack 通知你团队的绝佳时机。例如，我们可以在 Laravel 中的 AppServiceProvider 中附加一个回调事件：
rrreee
重试失败的任务
要想查看所有被放入 failed_jobs 数据表中的任务，你可以使用 Artisan 命令 queue:failed ：
rrreee
queue:failed 命令会列出任务 ID ，队列，以及失败的时间。任务 ID 可能会被用于重试失败的任务。例如，要重试一个任务 ID 为 5 的任务，使用如下命令：
rrreee
要重试所有失败的任务，执行 queue:retry 命令，将 all 作为 ID 传入：
rrreee
如果你想删除一个失败的任务，使用 queue:forget 命令：
rrreee
要清空所有失败的任务，使用 queue:flushKemudian, apabila anda menjalankan pekerja beratur
, anda harus menggunakan suis --try dalam perintah queue:work untuk menentukan bilangan maksimum kali tugas itu perlu dicuba untuk berlari. Jika tiada nilai ditentukan untuk pilihan --try, gelung tak terhingga akan cuba menjalankan tugas:
rrreee

Bersihkan selepas kegagalan tugas
Anda boleh mentakrifkan kaedah gagal secara langsung dalam kelas tugasan, membolehkan anda untuk melaksanakan sasaran apabila tugasan gagal untuk pembersihan tugas ini. Ini adalah tempat yang sangat baik untuk menghantar makluman kepada pengguna atau menyambung semula sebarang tindakan yang dilakukan oleh tugas itu. Pengecualian yang menyebabkan tugas gagal akan diserahkan kepada kaedah gagal: 🎜rrreee🎜🎜🎜
🎜
Acara Kegagalan Tugas
🎜Jika anda ingin mendaftar acara boleh panggil apabila tugas gagal, anda boleh menggunakan Queue::failing kaedah. Acara ini adalah masa yang tepat untuk memberitahu pasukan anda melalui e-mel atau Slack🎜. Sebagai contoh, kita boleh melampirkan acara panggil balik pada AppServiceProvider dalam Laravel: 🎜rrreee🎜🎜🎜
🎜
Cuba semula kerja yang gagal
🎜Untuk melihat semua kerja yang telah diletakkan dalam jadual data failed_jobs, anda boleh menggunakan perintah Artisan queue:failed : 🎜rrreee🎜queue:failed Perintah akan menyenaraikan ID tugas, baris gilir dan masa kegagalan. ID tugasan boleh digunakan untuk mencuba semula tugasan yang gagal. Contohnya, untuk mencuba semula tugasan dengan ID tugas 5, gunakan arahan berikut: 🎜rrreee🎜Untuk mencuba semula semua tugasan yang gagal, laksanakan perintah queue:retry dan gantikan < code >semua Masukkan sebagai ID: 🎜rrreee🎜 Jika anda ingin memadamkan tugasan yang gagal, gunakan perintah queue:forget: 🎜rrreee🎜Untuk mengosongkan semua tugasan yang gagal, gunakan queue:flush Perintah: 🎜rrreee🎜🎜🎜🎜🎜🎜
Abaikan model yang hilang
Apabila menyuntik model Eloquent ke dalam tugasan, model akan disiri secara automatik sebelum dimasukkan ke dalam baris gilir dan dipulihkan apabila tugasan itu dilaksanakan. Walau bagaimanapun, jika model dipadamkan semasa tugasan sedang menunggu untuk dilaksanakan, tugasan itu mungkin gagal dan membuang ModelNotFoundException . ModelNotFoundException 。
为了方便，你可以选择设置任务的 deleteWhenMissingModels 属性为 true 来自动地删除缺失模型的任务。
rrreee
任务事件
通过在 Queue facade 中使用 before 和 after 方法，你可以指定一个队列任务被执行前后的回调。这些回调是添加额外的日志或增加统计的绝好时机。通常，你应该在服务提供者中调用这些方法。例如，我们可以使用 Laravel 的 AppServiceProvider ：
rrreee
在 Queue facade 使用 looping
Untuk kemudahan, anda boleh memilih untuk menetapkan atribut deleteWhenMissingModels tugas kepada true untuk memadamkan tugasan dengan model yang tiada secara automatik.
rrreee
Acara Tugasan
🎜Oleh Queue Menggunakan kaedah sebelum dan selepas dalam fasad, anda boleh menentukan panggilan balik sebelum dan selepas tugas baris gilir dilaksanakan. Panggilan balik ini merupakan peluang terbaik untuk menambah log tambahan atau meningkatkan statistik. Biasanya, anda harus menghubungi kaedah ini dalam pembekal perkhidmatan. Sebagai contoh, kita boleh menggunakan AppServiceProvider Laravel: 🎜rrreee🎜Gunakan kaedah gelung dalam fasad Queue untuk melaksanakan panggilan balik sebelum pemproses cuba untuk mendapatkan tugas tersebut. Sebagai contoh, anda mungkin mahu menggunakan penutupan untuk melancarkan semula transaksi yang belum ditutup oleh tugasan yang gagal sebelum ini: 🎜rrreee🎜Artikel ini mula-mula muncul di tapak web 🎜LearnKu.com🎜. 🎜🎜
← Pembangunan pek pengembangan
Penjadualan tugas →
serahkan
Rumah video Soal Jawab saya
Laman web PHP Cina
Rumah Kursus Artikel Soal Jawab Kamus Manual Muat turun cari APPMuat turun

beratur

Connection Vs. Queue

驱动的必要设置

Database

Redis

Pangkalan Data

Redis

Pakej sambungan kebergantungan pemacu baris gilir lain

创建任务

生成任务类

任务类结构

Mencipta pekerjaan

Jana kelas tugas

Struktur kelas tugas

Agihkan tugas

延迟分发

同步调度

工作链

工作链连接 & 队列

自定义连接 & 队列

分发任务到指定队列

分发任务到指定连接

Pengagihan Tertunda

penghantaran segerak

Rantai Kerja

Sambungan & Baris Gilir Rantai Kerja

Sambungan & baris gilir tersuai

Agihkan tugas kepada sambungan yang ditentukan

Nyatakan bilangan maksimum percubaan tugasan/nilai tamat masa

Bilangan maksimum percubaan

基于时间的尝试

超时

Penghadan Kekerapan

错误处理

{tip} Apabila menggunakan pengehadan kekerapan, bilangan pelaksanaan tugas yang berjaya percubaan Ia boleh menjadi sukar untuk ditentukan. Jadi, adalah berguna untuk menggabungkan had kekerapan dengan had masa

Run Queue Handler

指定连接 & 队列

执行单一任务

处理所有队列的任务然后退出

资源注意事项

Nyatakan sambungan & baris gilir

Laksanakan satu tugasan

Proses semua tugasan beratur dan kemudian keluar

Nota Sumber

Keutamaan Beratur

队列处理器 & 部署

任务过期 & 超时

任务过期

Tanggal Tempoh Tugas

Tamat Masa Pemproses

队列进程睡眠时间

Supervisor 配置

安装 Supervisor

配置 Supervisor

Konfigurasi penyelia

Start Supervisor

任务失败后清理

任务失败事件

重试失败的任务

Bersihkan selepas kegagalan tugas

Acara Kegagalan Tugas

Cuba semula kerja yang gagal

Abaikan model yang hilang

任务事件

Acara Tugasan

Laman web PHP Cina